Revise NotEqual

docs/template_plugin/tests/functional/op_reference/notequal.cpp

@@ -0,0 +1,78 @@
+// Copyright (C) 2018-2021 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <gtest/gtest.h>
+
+#include <ie_core.hpp>
+#include <ie_ngraph_utils.hpp>
+#include <ngraph/ngraph.hpp>
+#include <shared_test_classes/base/layer_test_utils.hpp>
+
+#include "comparison.hpp"
+
+using namespace ngraph;
+using namespace InferenceEngine;
+using ComparisonTypes = ngraph::helpers::ComparisonTypes;
+
+namespace reference_tests {
+    namespace ComparisonOpsRefTestDefinitions {
+        namespace {
+            TEST_P(ReferenceComparisonLayerTest, GreaterCompareWithHardcodedRefs) {
+                Exec();
+            }
+
+            template <element::Type_t IN_ET>
+            std::vector<RefComparisonParams> generateComparisonParams(const element::Type& type) {
+                using T = typename element_type_traits<IN_ET>::value_type;
+                std::vector<RefComparisonParams> compParams {
+                    Builder {}
+                    .compType(ComparisonTypes::NOT_EQUAL)
+                    .input1({{2, 2}, type, std::vector<T> {1, 0, 10, 999}})
+                    .input2({{2, 2}, type, std::vector<T> {1, 0, 10, 999}})
+                    .expected({{2, 2}, element::boolean, std::vector<char> {0, 0, 0, 0}}),
+                    Builder {}
+                    .compType(ComparisonTypes::NOT_EQUAL)
+                    .input1({{2, 3}, type, std::vector<T> {0, 15, 45, 10, 5, 10}})
+                    .input2({{2, 3}, type, std::vector<T> {1, 15, -45, 10, 50, 10}})
+                    .expected({{2, 3}, element::boolean, std::vector<char> {1, 0, 1, 0, 1, 0}}),
+                    Builder {}
+                    .compType(ComparisonTypes::NOT_EQUAL)
+                    .input1({{1}, type, std::vector<T> {23}})
+                    .input2({{1}, type, std::vector<T> {23}})
+                    .expected({{1}, element::boolean, std::vector<char> {0}}),
+                    Builder {}
+                    .compType(ComparisonTypes::NOT_EQUAL)
+                    .input1({{1}, type, std::vector<T> {20}})
+                    .input2({{1}, type, std::vector<T> {10}})
+                    .expected({{1}, element::boolean, std::vector<char> {1}}),
+                    Builder {}
+                    .compType(ComparisonTypes::NOT_EQUAL)
+                    .input1({{2, 4}, type, std::vector<T> {0, 12, 23, 0, 1, 5, 12, 8}})
+                    .input2({{2, 4}, type, std::vector<T> {0, 12, 23, 0, 10, 5, 11, 8}})
+                    .expected({{2, 4}, element::boolean, std::vector<char> {0, 0, 0, 0, 1, 0, 1, 0}});
+                return compParams;
+            }
+
+            std::vector<RefComparisonParams> generateComparisonCombinedParams() {
+                const std::vector<std::vector<RefComparisonParams>> compTypeParams {
+                    generateComparisonParams<element::Type_t::f32>(element::f32),
+                    generateComparisonParams<element::Type_t::f16>(element::f16),
+                    generateComparisonParams<element::Type_t::i32>(element::i32),
+                    generateComparisonParams<element::Type_t::i64>(element::i64),
+                    generateComparisonParams<element::Type_t::u32>(element::u32),
+                    generateComparisonParams<element::Type_t::u64>(element::u64),
+                    generateComparisonParams<element::Type_t::boolean>(element::boolean)};
+                std::vector<RefComparisonParams> combinedParams;
+
+                for (const auto& params : compTypeParams) {
+                    combinedParams.insert(combinedParams.end(), params.begin(), params.end());
+                }
+                return combinedParams;
+            }
+
+        } // namespace
+        INSTANTIATE_TEST_SUITE_P(smoke_Comparison_With_Hardcoded_Refs, ReferenceComparisonLayerTest, ::testing::ValuesIn(generateComparisonCombinedParams()),
+                                 ReferenceComparisonLayerTest::getTestCaseName);
+    } // namespace ComparisonOpsRefTestDefinitions
+} // namespace reference_tests

inference-engine/tests/functional/shared_test_classes/src/base/layer_test_utils.cpp

@@ -45,21 +45,22 @@ void LayerTestsCommon::Run() {
         s.updateOPsStats(function, PassRate::Statuses::CRASHED);
     }
 
+    auto function_ = function;
     try {
         LoadNetwork();
         GenerateInputs();
         Infer();
         Validate();
-        s.updateOPsStats(function, PassRate::Statuses::PASSED);
+        s.updateOPsStats(function_, PassRate::Statuses::PASSED);
     }
     catch (const std::runtime_error &re) {
-        s.updateOPsStats(function, PassRate::Statuses::FAILED);
+        s.updateOPsStats(function_, PassRate::Statuses::FAILED);
         GTEST_FATAL_FAILURE_(re.what());
     } catch (const std::exception &ex) {
-        s.updateOPsStats(function, PassRate::Statuses::FAILED);
+        s.updateOPsStats(function_, PassRate::Statuses::FAILED);
         GTEST_FATAL_FAILURE_(ex.what());
     } catch (...) {
-        s.updateOPsStats(function, PassRate::Statuses::FAILED);
+        s.updateOPsStats(function_, PassRate::Statuses::FAILED);
         GTEST_FATAL_FAILURE_("Unknown failure occurred.");
     }
 }