[NPU] Extend functional tests to cover sub-byte element types (#32279)

### Details:
- *Extend ZeroTensorTests. Add new test
`CopyZeroTensorAndCheckTensorDataType` to check all supported tensor
data types.*
- *Update func tests `OVInferRequestIOTensorSetPrecisionTestNPU`. Use
model with same type as precision tested, so that `set_tensor` is called
for all tested precisions.*
 - *Update skip config with supported precision tests.*

### Tickets:
 - *CVS-174265*

---------

Signed-off-by: Stefania Hergane <[email protected]>

Author: StefaniaHergane

src/plugins/intel_npu/tests/functional/internal/backend/zero_tensor_tests.cpp

@@ -12,9 +12,25 @@
 using namespace ov::test::behavior;
 
 const std::vector<ov::AnyMap> configsInferRequestRunTests = {{}};
+const std::vector<ov::element::Type> defaultTensorDataType = {ov::element::f32};
 
 INSTANTIATE_TEST_SUITE_P(compatibility_smoke_BehaviorTest,
                          ZeroTensorTests,
                          ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_NPU),
-                                            ::testing::ValuesIn(configsInferRequestRunTests)),
+                                            ::testing::ValuesIn(configsInferRequestRunTests),
+                                            ::testing::ValuesIn(defaultTensorDataType)),
                          ZeroTensorTests::getTestCaseName);
+
+const std::vector<ov::element::Type> supportedTensorDataTypes = {
+    ov::element::f32,    ov::element::f16, ov::element::bf16, ov::element::f8e4m3, ov::element::f8e5m2,
+    ov::element::f8e8m0, ov::element::nf4, ov::element::u2,   ov::element::u4,     ov::element::i4,
+    ov::element::u8,     ov::element::i8,  ov::element::u16,  ov::element::i16,    ov::element::u32,
+    ov::element::i32,    ov::element::u64, ov::element::i64,  ov::element::f64,    ov::element::boolean,
+};
+
+INSTANTIATE_TEST_SUITE_P(compatibility_smoke_BehaviorTest,
+                         ZeroTensorTestsCheckDataType,
+                         ::testing::Combine(::testing::Values(ov::test::utils::DEVICE_NPU),
+                                            ::testing::ValuesIn(configsInferRequestRunTests),
+                                            ::testing::ValuesIn(supportedTensorDataTypes)),
+                         ZeroTensorTestsCheckDataType::getTestCaseName);

src/plugins/intel_npu/tests/functional/internal/backend/zero_tensor_tests.hpp

@@ -33,9 +33,10 @@
 #include "zero_backend.hpp"
 #include "zero_tensor.hpp"
 
-using CompilationParams = std::tuple<std::string,  // Device name
-                                     ov::AnyMap    // Config
-                                     >;
+using CompilationParamsAndTensorDataType = std::tuple<std::string,       // Device name
+                                                      ov::AnyMap,        // Config
+                                                      ov::element::Type  // Tensor data type
+                                                      >;
 
 using ::testing::AllOf;
 using ::testing::HasSubstr;
@@ -44,19 +45,21 @@ namespace ov {
 namespace test {
 namespace behavior {
 class ZeroTensorTests : public ov::test::behavior::OVPluginTestBase,
-                        public testing::WithParamInterface<CompilationParams> {
+                        public testing::WithParamInterface<CompilationParamsAndTensorDataType> {
 protected:
     std::shared_ptr<ov::Core> core = utils::PluginCache::get().core();
     ov::AnyMap configuration;
+    ov::element::Type element_type;
     std::shared_ptr<::intel_npu::ZeroInitStructsHolder> init_struct;
     std::shared_ptr<::intel_npu::OptionsDesc> options = std::make_shared<::intel_npu::OptionsDesc>();
     ::intel_npu::Config npu_config = ::intel_npu::Config(options);
 
 public:
-    static std::string getTestCaseName(testing::TestParamInfo<CompilationParams> obj) {
+    static std::string getTestCaseName(const testing::TestParamInfo<CompilationParamsAndTensorDataType>& obj) {
         std::string targetDevice;
         ov::AnyMap configuration;
-        std::tie(targetDevice, configuration) = obj.param;
+        ov::element::Type type;
+        std::tie(targetDevice, configuration, type) = obj.param;
         std::replace(targetDevice.begin(), targetDevice.end(), ':', '_');
         targetDevice = ov::test::utils::getTestsPlatformFromEnvironmentOr(ov::test::utils::DEVICE_NPU);
 
@@ -69,12 +72,15 @@ class ZeroTensorTests : public ov::test::behavior::OVPluginTestBase,
                 configItem.second.print(result);
             }
         }
+        if (!type.get_type_name().empty()) {
+            result << "tensorDataType=" << type.get_type_name() << "_";
+        }
 
         return result.str();
     }
 
     void SetUp() override {
-        std::tie(target_device, configuration) = this->GetParam();
+        std::tie(target_device, configuration, element_type) = this->GetParam();
 
         SKIP_IF_CURRENT_TEST_IS_DISABLED()
         OVPluginTestBase::SetUp();
@@ -95,12 +101,12 @@ TEST_P(ZeroTensorTests, AllocateDeleteAllocateZeroTensor) {
     SKIP_IF_CURRENT_TEST_IS_DISABLED()
 
     auto shape = Shape{1, 2, 2, 2};
-    auto zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element::f32, shape, true);
+    auto zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element_type, shape, true);
     ASSERT_TRUE(::intel_npu::zeroUtils::memory_was_allocated_in_the_same_l0_context(init_struct->getContext(),
                                                                                     zero_tensor->data()));
 
     zero_tensor = {};
-    zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element::f32, shape, false);
+    zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element_type, shape, false);
     ASSERT_TRUE(::intel_npu::zeroUtils::memory_was_allocated_in_the_same_l0_context(init_struct->getContext(),
                                                                                     zero_tensor->data()));
 
@@ -115,10 +121,10 @@ TEST_P(ZeroTensorTests, CheckSetSmallerShape) {
 
     auto shape = Shape{1, 20, 20, 20};
     auto shape_size = ov::shape_size(shape);
-    auto zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element::f32, shape, true);
+    auto zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element_type, shape, true);
     EXPECT_EQ(shape, zero_tensor->get_shape());
     EXPECT_EQ(shape_size, zero_tensor->get_size());
-    EXPECT_EQ(shape_size * sizeof(ov::element::f32), zero_tensor->get_byte_size());
+    EXPECT_EQ(shape_size * element_type.size(), zero_tensor->get_byte_size());
 
     auto data = zero_tensor->data();
 
@@ -128,7 +134,7 @@ TEST_P(ZeroTensorTests, CheckSetSmallerShape) {
     zero_tensor->set_shape(new_shape);
     EXPECT_EQ(new_shape, zero_tensor->get_shape());
     EXPECT_EQ(new_shape_size, zero_tensor->get_size());
-    EXPECT_EQ(new_shape_size * sizeof(ov::element::f32), zero_tensor->get_byte_size());
+    EXPECT_EQ(new_shape_size * element_type.size(), zero_tensor->get_byte_size());
     EXPECT_EQ(data, zero_tensor->data());
     ASSERT_TRUE(::intel_npu::zeroUtils::memory_was_allocated_in_the_same_l0_context(init_struct->getContext(),
                                                                                     zero_tensor->data()));
@@ -139,10 +145,10 @@ TEST_P(ZeroTensorTests, CheckSetBiggerShape) {
 
     auto shape = Shape{1, 20, 20, 20};
     auto shape_size = ov::shape_size(shape);
-    auto zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element::f32, shape, false);
+    auto zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element_type, shape, false);
     EXPECT_EQ(shape, zero_tensor->get_shape());
     EXPECT_EQ(shape_size, zero_tensor->get_size());
-    EXPECT_EQ(shape_size * sizeof(ov::element::f32), zero_tensor->get_byte_size());
+    EXPECT_EQ(shape_size * element_type.size(), zero_tensor->get_byte_size());
 
     auto new_shape = Shape{1, 50, 50, 50};
     auto new_shape_size = ov::shape_size(new_shape);
@@ -152,7 +158,7 @@ TEST_P(ZeroTensorTests, CheckSetBiggerShape) {
         zero_tensor->set_shape(new_shape);
         EXPECT_EQ(new_shape, zero_tensor->get_shape());
         EXPECT_EQ(new_shape_size, zero_tensor->get_size());
-        EXPECT_EQ(new_shape_size * sizeof(ov::element::f32), zero_tensor->get_byte_size());
+        EXPECT_EQ(new_shape_size * element_type.size(), zero_tensor->get_byte_size());
         ASSERT_TRUE(zero_tensor->memory_address_changed());
         ASSERT_TRUE(::intel_npu::zeroUtils::memory_was_allocated_in_the_same_l0_context(init_struct->getContext(),
                                                                                         zero_tensor->data()));
@@ -164,122 +170,118 @@ TEST_P(ZeroTensorTests, CheckSetBiggerShape) {
 TEST_P(ZeroTensorTests, CheckIsContinuousZeroTensorScalar) {
     SKIP_IF_CURRENT_TEST_IS_DISABLED()
 
-    auto zero_tensor =
-        std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, ov::element::f32, Shape{}, true);
+    auto zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element_type, Shape{}, true);
     auto data = zero_tensor->data();
     auto strides = zero_tensor->get_strides();
 
     ov::Tensor view_tensor;
 
-    view_tensor = ov::Tensor(ov::element::f32, ov::Shape{}, data, strides);
+    view_tensor = ov::Tensor(element_type, ov::Shape{}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 }
 
 TEST_P(ZeroTensorTests, CheckIsContinuousHostTensor1Dimension) {
     SKIP_IF_CURRENT_TEST_IS_DISABLED()
 
     auto zero_tensor =
-        std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, ov::element::f32, Shape{128}, true);
+        std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element_type, Shape{128}, true);
 
     auto data = zero_tensor->data();
     auto strides = zero_tensor->get_strides();
 
     ov::Tensor view_tensor;
 
-    view_tensor = ov::Tensor(ov::element::f32, ov::Shape{128}, data, strides);
+    view_tensor = ov::Tensor(element_type, ov::Shape{128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 
-    view_tensor = ov::Tensor(ov::element::f32, ov::Shape{16}, data, strides);
+    view_tensor = ov::Tensor(element_type, ov::Shape{16}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 }
 
 TEST_P(ZeroTensorTests, CheckIsContinuousZeroTensor2Dimensions) {
     SKIP_IF_CURRENT_TEST_IS_DISABLED()
 
     auto zero_tensor =
-        std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, ov::element::f32, Shape{32, 128}, true);
+        std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element_type, Shape{32, 128}, true);
     auto data = zero_tensor->data();
     auto strides = zero_tensor->get_strides();
 
     ov::Tensor view_tensor;
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{16, 128}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{16, 128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{1, 128}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{1, 128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{1, 16}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{1, 16}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{2, 16}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{2, 16}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), false);
 }
 
 TEST_P(ZeroTensorTests, CheckIsContinuousZeroTensor3Dimensions) {
     SKIP_IF_CURRENT_TEST_IS_DISABLED()
 
     auto zero_tensor =
-        std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, ov::element::f32, Shape{5, 32, 128}, true);
+        std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element_type, Shape{5, 32, 128}, true);
     auto data = zero_tensor->data();
     auto strides = zero_tensor->get_strides();
 
     ov::Tensor view_tensor;
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{2, 32, 128}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{2, 32, 128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{2, 16, 128}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{2, 16, 128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), false);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{1, 1, 128}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{1, 1, 128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{1, 1, 64}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{1, 1, 64}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{1, 16, 128}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{1, 16, 128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 }
 
 TEST_P(ZeroTensorTests, CheckIsContinuousZeroTensor4Dimensions) {
     SKIP_IF_CURRENT_TEST_IS_DISABLED()
 
-    auto zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct,
-                                                                 npu_config,
-                                                                 ov::element::f32,
-                                                                 Shape{3, 5, 32, 128},
-                                                                 true);
+    auto zero_tensor =
+        std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element_type, Shape{3, 5, 32, 128}, true);
     auto data = zero_tensor->data();
     auto strides = zero_tensor->get_strides();
 
     ov::Tensor view_tensor;
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{1, 2, 32, 128}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{1, 2, 32, 128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{2, 5, 32, 128}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{2, 5, 32, 128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{2, 2, 32, 128}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{2, 2, 32, 128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), false);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{1, 2, 5, 128}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{1, 2, 5, 128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), false);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{3, 5, 32, 64}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{3, 5, 32, 64}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), false);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{1, 1, 16, 128}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{1, 1, 16, 128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{2, 1, 16, 128}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{2, 1, 16, 128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), false);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{1, 1, 1, 128}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{1, 1, 1, 128}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 
-    view_tensor = ov::Tensor(ov::element::f32, Shape{1, 1, 1, 32}, data, strides);
+    view_tensor = ov::Tensor(element_type, Shape{1, 1, 1, 32}, data, strides);
     EXPECT_EQ(view_tensor.is_continuous(), true);
 }
 
@@ -289,8 +291,8 @@ TEST_P(ZeroTensorTests, CopyDefaultTensorExpectedThrow) {
     auto shape = Shape{1, 2, 2, 2};
 
     // shape size is unaligned to standard page size, expect to fail
-    auto data = static_cast<float*>(::operator new(ov::shape_size(shape) * sizeof(ov::element::f32)));
-    auto default_tensor = make_tensor(ov::element::f32, shape, data);
+    auto data = static_cast<float*>(::operator new(ov::shape_size(shape) * element_type.size()));
+    auto default_tensor = make_tensor(element_type, shape, data);
     ASSERT_THROW(auto zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, default_tensor, npu_config),
                  ::intel_npu::ZeroTensorException);
 
@@ -302,8 +304,7 @@ TEST_P(ZeroTensorTests, CopyZeroTensorAndKeepAlive) {
 
     auto shape = Shape{1, 2, 2, 2};
 
-    auto zero_tensor =
-        std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, ov::element::f32, shape, true);
+    auto zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element_type, shape, true);
 
     auto copy_zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, zero_tensor, npu_config);
 
@@ -325,8 +326,7 @@ TEST_P(ZeroTensorTests, CopyHostTensorAndKeepAlive) {
     auto zero_context = std::make_shared<::intel_npu::RemoteContextImpl>(engine_backend);
     auto shape = Shape{1, 2, 2, 2};
 
-    auto host_tensor =
-        std::make_shared<::intel_npu::ZeroHostTensor>(zero_context, init_struct, ov::element::f32, shape);
+    auto host_tensor = std::make_shared<::intel_npu::ZeroHostTensor>(zero_context, init_struct, element_type, shape);
 
     auto copy_zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, host_tensor, npu_config);
 
@@ -349,7 +349,7 @@ TEST_P(ZeroTensorTests, CopyRemoteTensorAndKeepAlive) {
     auto shape = Shape{1, 2, 2, 2};
 
     auto remote_tensor =
-        std::make_shared<::intel_npu::ZeroRemoteTensor>(zero_context, init_struct, ov::element::f32, shape);
+        std::make_shared<::intel_npu::ZeroRemoteTensor>(zero_context, init_struct, element_type, shape);
 
     auto copy_zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, remote_tensor, npu_config);
 
@@ -375,14 +375,28 @@ TEST_P(ZeroTensorTests, CopyRemoteTensorFromAnotherContextThrow) {
                          {ov::intel_npu::tensor_type.name(), {ov::intel_npu::TensorType::INPUT}}};
 
     auto context = core->create_context(target_device, params);
-    auto remote_tensor = context.create_tensor(ov::element::f32, shape);
+    auto remote_tensor = context.create_tensor(element_type, shape);
     auto remote_tensor_impl = get_tensor_impl(remote_tensor);
 
     ASSERT_THROW(
         auto zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, remote_tensor_impl, npu_config),
         ::intel_npu::ZeroTensorException);
 }
 
+using ZeroTensorTestsCheckDataType = ZeroTensorTests;
+
+TEST_P(ZeroTensorTestsCheckDataType, CopyZeroTensorAndCheckTensorDataType) {
+    SKIP_IF_CURRENT_TEST_IS_DISABLED()
+
+    auto shape = Shape{1, 2, 2, 2};
+
+    auto zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, npu_config, element_type, shape, true);
+    EXPECT_EQ(element_type, zero_tensor->get_element_type());
+
+    auto copy_zero_tensor = std::make_shared<::intel_npu::ZeroTensor>(init_struct, zero_tensor, npu_config);
+    EXPECT_EQ(zero_tensor->get_element_type(), copy_zero_tensor->get_element_type());
+}
+
 }  // namespace behavior
 }  // namespace test
 }  // namespace ov