iplugin_test.cpp

// Copyright (C) 2018-2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//

#include "openvino/runtime/iplugin.hpp"

#include <gmock/gmock-spec-builders.h>
#include <gtest/gtest.h>

#include "openvino/core/node_output.hpp"
#include "openvino/core/node_vector.hpp"
#include "openvino/core/partial_shape.hpp"
#include "openvino/op/parameter.hpp"
#include "openvino/op/relu.hpp"
#include "openvino/op/result.hpp"
#include "openvino/runtime/compiled_model.hpp"
#include "openvino/runtime/iinfer_request.hpp"
#include "openvino/runtime/make_tensor.hpp"
#include "unit_test_utils/mocks/openvino/runtime/mock_icompiled_model.hpp"
#include "unit_test_utils/mocks/openvino/runtime/mock_iplugin.hpp"
#include "unit_test_utils/mocks/openvino/runtime/mock_isync_infer_request.hpp"

using namespace ::testing;
using namespace std;

class IPluginTest : public ::testing::Test {
private:
    std::shared_ptr<ov::Model> create_model() {
        auto param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{1, 3, 2, 2});
        param->set_friendly_name("Param");
        param->output(0).set_names({"param"});

        auto relu = std::make_shared<ov::op::v0::Relu>(param);
        relu->set_friendly_name("ReLU");
        relu->output(0).set_names({"relu"});

        return std::make_shared<ov::Model>(ov::OutputVector{relu->output(0)}, ov::ParameterVector{param});
    }

protected:
    shared_ptr<ov::IPlugin> plugin;
    shared_ptr<ov::MockIPlugin> mock_plugin_impl;
    shared_ptr<ov::MockICompiledModel> mock_compiled_model;
    shared_ptr<ov::MockISyncInferRequest> mock_infer_request;
    std::shared_ptr<const ov::Model> model = create_model();
    std::string pluginId;

    void TearDown() override {
        EXPECT_TRUE(Mock::VerifyAndClearExpectations(mock_plugin_impl.get()));
        EXPECT_TRUE(Mock::VerifyAndClearExpectations(mock_compiled_model.get()));
        EXPECT_TRUE(Mock::VerifyAndClearExpectations(mock_infer_request.get()));
    }

    void SetUp() override {
        pluginId = "TEST";
        mock_plugin_impl.reset(new ov::MockIPlugin());
        mock_plugin_impl->set_device_name(pluginId);
        plugin = std::static_pointer_cast<ov::IPlugin>(mock_plugin_impl);
        mock_compiled_model = make_shared<ov::MockICompiledModel>(model, plugin);
        ON_CALL(*mock_compiled_model.get(), inputs()).WillByDefault(ReturnRefOfCopy(model->inputs()));
        ON_CALL(*mock_compiled_model.get(), outputs()).WillByDefault(ReturnRefOfCopy(model->outputs()));
        mock_infer_request = make_shared<ov::MockISyncInferRequest>(mock_compiled_model);
    }

    void getInferRequestWithMockImplInside(std::shared_ptr<ov::IAsyncInferRequest>& request) {
        std::shared_ptr<ov::ICompiledModel> compiled_model;
        EXPECT_CALL(*mock_plugin_impl.get(), compile_model(A<const std::shared_ptr<const ov::Model>&>(), _))
            .WillOnce(Return(mock_compiled_model));
        EXPECT_CALL(*mock_compiled_model.get(), create_sync_infer_request()).WillOnce(Return(mock_infer_request));
        ON_CALL(*mock_compiled_model.get(), create_infer_request()).WillByDefault([&]() {
            return mock_compiled_model->create_infer_request_default();
        });
        compiled_model = plugin->compile_model(model, {});
        ASSERT_NE(nullptr, compiled_model);
        request = compiled_model->create_infer_request();
        ASSERT_NE(nullptr, request);
    }
};

MATCHER_P(blob_in_map_pointer_is_same, ref_blob, "") {
    return reinterpret_cast<float*>(arg.begin()->second->buffer()) == reinterpret_cast<float*>(ref_blob->buffer());
}

TEST_F(IPluginTest, failToSetTensorWithIncorrectPort) {
    auto incorrect_param = std::make_shared<ov::op::v0::Parameter>(ov::element::f32, ov::PartialShape{1, 2});
    ov::SoPtr<ov::ITensor> tensor = ov::make_tensor(ov::element::f32, {1, 1, 1, 1});
    std::string refError = "Cannot find tensor for port";
    std::shared_ptr<ov::IAsyncInferRequest> infer_request;
    getInferRequestWithMockImplInside(infer_request);
    try {
        infer_request->set_tensor(incorrect_param->output(0), tensor);
    } catch (ov::Exception& ex) {
        ASSERT_TRUE(std::string{ex.what()}.find(refError) != std::string::npos)
            << "\tExpected: " << refError << "\n\tActual: " << ex.what();
    }
}

TEST_F(IPluginTest, failToSetEmptyITensor) {
    ov::SoPtr<ov::ITensor> tensor;
    std::string refError = "Failed to set tensor. ";
    std::shared_ptr<ov::IAsyncInferRequest> infer_request;
    getInferRequestWithMockImplInside(infer_request);
    try {
        infer_request->set_tensor(model->input(0), tensor);
    } catch (ov::Exception& ex) {
        ASSERT_TRUE(std::string{ex.what()}.find(refError) != std::string::npos)
            << "\tExpected: " << refError << "\n\tActual: " << ex.what();
    }
}

TEST_F(IPluginTest, SetTensorWithCorrectPort) {
    ov::SoPtr<ov::ITensor> tensor = ov::make_tensor(ov::element::f32, {1, 3, 2, 2});
    std::shared_ptr<ov::IAsyncInferRequest> infer_request;
    getInferRequestWithMockImplInside(infer_request);
    EXPECT_NO_THROW(infer_request->set_tensor(model->input(0), tensor));
}