[OV CPU] Convert Node converting integer to unsigned one, it did clamp (#32389)

As Convert Op's [Specification
](https://docs.openvino.ai/2025/documentation/openvino-ir-format/operation-sets/operation-specs/type/convert-1.html)
said.

> Conversion of negative signed integer to unsigned integer value
happens in accordance with c++ standard. Notably, result is the unique
value of the destination unsigned type that is congruent to the source
integer modulo 2^N (where N is the bit width of the destination type).
**For example, when an int32 value -1 is converted to uint32 the result
will be uint32 max which is 4,294,967,295.**

### Reproduce:

Test when int32 value -1 convert to uint8
- OV GPU/NPU, got 255 (match the spec)
- OV CPU, it uses the boundary to clamp, got 0, not 255 (did't match the
spec)


```
import openvino as ov
import numpy as np

input_data = np.full((2, 2), -1, dtype=np.int32)
expected_output_data = np.full((2, 2), 2**8 - 1, dtype=np.uint8)

input_param = ov.op.Parameter(ov.runtime.Type.i32, ov.Shape([2, 2]))
convert_op = ov.opset1.convert(input_param, destination_type=ov.runtime.Type.u8)
model = ov.Model(results=[convert_op], parameters=[input_param], name="int32_to_uint8_convert")
core = ov.Core()
compiled_model = core.compile_model(model, "CPU")

results = compiled_model(input_data)
actual_output_data = results[compiled_model.outputs[0]]

try:
    print("--- Verification ---")
    np.testing.assert_array_equal(actual_output_data, expected_output_data)
    print("SUCCESS: Actual output matches expected output.")
except AssertionError as e:
    print(f"FAILED: Output mismatch!\n{e}")
```

```
--- Verification ---
FAILED: Output mismatch!
Arrays are not equal
...
 ACTUAL: array([[0, 0],[0, 0]], dtype=uint8)
 DESIRED: array([[255, 255],[255, 255]], dtype=uint8)
```

### Tickets:
 - *CVS-172796*

Author: bopeng1234

src/frontends/onnx/tests/__init__.py

@@ -51,7 +51,6 @@ def xfail_test(reason="Mark the test as expected to fail", strict=True):
 xfail_issue_38708 = xfail_test(reason="RuntimeError: While validating ONNX node '<Node(Slice): y>': "
                                       "Axes input must be constant")
 skip_bitwise_ui64 = pytest.mark.skip(reason="AssertionError: Not equal to tolerance rtol=0.001, atol=1e-07")
-xfail_issue_99949 = xfail_test(reason="Bitwise operators are not supported")
 xfail_issue_99950 = xfail_test(reason="CenterCropPad func is not supported")
 xfail_issue_99952 = xfail_test(reason="Col2Im operator is not supported")
 xfail_issue_99954 = xfail_test(reason="Constant Pad - RuntimeError: Shape inference of Reference node with name y failed")

src/frontends/onnx/tests/tests_python/test_backend.py

@@ -40,7 +40,6 @@
     xfail_issue_82039,
     xfail_issue_90649,
     skip_bitwise_ui64,
-    xfail_issue_99949,
     xfail_issue_99950,
     xfail_issue_99952,
     xfail_issue_99954,
@@ -381,10 +380,6 @@ def expect_fail(test_case_path, xfail):  # type: (str) -> None
         "OnnxBackendNodeModelTest.test_bitwise_or_ui64_bcast_3v1d_cpu",
         "OnnxBackendNodeModelTest.test_bitwise_xor_ui64_bcast_3v1d_cpu",
     ),
-    (
-        xfail_issue_99949,
-        "OnnxBackendNodeModelTest.test_bitwise_not_3d_cpu",
-    ),
     (
         xfail_issue_99950,
         "OnnxBackendNodeModelTest.test_center_crop_pad_crop_axes_chw_expanded_cpu",

src/plugins/intel_cpu/src/nodes/common/cpu_convert.cpp

@@ -550,8 +550,9 @@ struct ConvertPrecision<std::tuple<src_t, dst_t>> {
         // Align with the behavior of ngraph ref and jit implementation. Conversion from f8e4m3-inf
         // to float should output float-inf instead of f8e4m3-max. Proper handling of special values
         // (nan, inf, overflow) has already been assured by the conversion process.
-        if (std::is_same_v<src_t, ov::float8_e4m3> || std::is_same_v<src_t, ov::float8_e5m2> ||
-            std::is_same_v<dst_t, ov::float8_e4m3> || std::is_same_v<dst_t, ov::float8_e5m2>) {
+        if (ov::intel_cpu::any_of_v<src_t, ov::float8_e4m3, ov::float8_e5m2> ||
+            ov::intel_cpu::any_of_v<dst_t, ov::float8_e4m3, ov::float8_e5m2> ||
+            (std::is_integral_v<src_t> && std::is_integral_v<dst_t>)) {
             parallel_for(ctx.size, [&](size_t i) {
                 dst[i] = static_cast<dst_t>(src[i]);
             });

src/plugins/intel_cpu/src/nodes/executors/acl/acl_convert.cpp

@@ -56,7 +56,7 @@ bool ACLConvertExecutor::init(const ConvertParams& convertParams,
             return false;
         }
     } else {
-        Status s = NECast::validate(&srcTensorInfo, &dstTensorInfo, ConvertPolicy::SATURATE);
+        Status s = NECast::validate(&srcTensorInfo, &dstTensorInfo, ConvertPolicy::WRAP);
         if (!s) {
             DEBUG_LOG("NECast validation failed: ", s.error_description());
             return false;
@@ -74,7 +74,7 @@ bool ACLConvertExecutor::init(const ConvertParams& convertParams,
     } else {
         acl_cast = std::make_unique<NECast>();
         configureThreadSafe([&] {
-            acl_cast->configure(&srcTensor, &dstTensor, ConvertPolicy::SATURATE);
+            acl_cast->configure(&srcTensor, &dstTensor, ConvertPolicy::WRAP);
         });
     }
     return true;

src/plugins/intel_cpu/tests/functional/shared_tests_instances/single_layer_tests/conversion.cpp

@@ -9,6 +9,7 @@
 
 namespace {
 using ov::test::ConversionLayerTest;
+using ov::test::ConversionSpecifyInputLayerTest;
 
 const std::vector<ov::test::utils::ConversionTypes> conversionOpTypes = {
     ov::test::utils::ConversionTypes::CONVERT,
@@ -79,4 +80,13 @@ INSTANTIATE_TEST_SUITE_P(smoke_ConversionFromF8LayerTest,
                                             ::testing::Values(ov::test::utils::DEVICE_CPU)),
                          ConversionLayerTest::getTestCaseName);
 
+INSTANTIATE_TEST_SUITE_P(smoke_ConversionI32ToU8LayerTest,
+                         ConversionSpecifyInputLayerTest,
+                         ::testing::Combine(::testing::Values(conversionOpTypes[0]),
+                                            ::testing::ValuesIn(ov::test::static_shapes_to_test_representation(shapes)),
+                                            ::testing::Values(ov::element::i32),
+                                            ::testing::Values(ov::element::u8),
+                                            ::testing::Values(ov::test::utils::DEVICE_CPU)),
+                         ConversionSpecifyInputLayerTest::getTestCaseName);
+
 }  // namespace

src/tests/functional/plugin/shared/include/shared_test_classes/single_op/conversion.hpp

@@ -26,5 +26,11 @@ class ConversionLayerTest : public testing::WithParamInterface<ConversionParamsT
 protected:
     void SetUp() override;
 };
+
+class ConversionSpecifyInputLayerTest : public ConversionLayerTest {
+protected:
+    void generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) override;
+};
+
 }  // namespace test
 }  // namespace ov

src/tests/functional/plugin/shared/include/single_op_tests/conversion.hpp

@@ -11,5 +11,8 @@ namespace test {
 TEST_P(ConversionLayerTest, Inference) {
     run();
 };
+TEST_P(ConversionSpecifyInputLayerTest, Inference) {
+    run();
+};
 }  // namespace test
 }  // namespace ov

src/tests/functional/plugin/shared/src/single_op/conversion.cpp

@@ -3,6 +3,8 @@
 //
 
 #include "shared_test_classes/single_op/conversion.hpp"
+
+#include "common_test_utils/data_utils.hpp"
 #include "openvino/op/convert.hpp"
 #include "openvino/op/convert_like.hpp"
 
@@ -57,5 +59,21 @@ void ConversionLayerTest::SetUp() {
     auto result = std::make_shared<ov::op::v0::Result>(conversion);
     function = std::make_shared<ov::Model>(result, params, "Conversion");
 }
+
+void ConversionSpecifyInputLayerTest::generate_inputs(const std::vector<ov::Shape>& targetInputStaticShapes) {
+    const auto& [conversion_type, shapes, input_type, convert_type, _targetDevice] = GetParam();
+    if (input_type != ov::element::i32 || convert_type != ov::element::u8) {
+        SubgraphBaseTest::generate_inputs(targetInputStaticShapes);
+        return;
+    }
+
+    inputs.clear();
+    const auto& funcInputs = function->inputs();
+    const auto& funcInput = funcInputs[0];
+    ov::Tensor tensor(funcInput.get_element_type(), targetInputStaticShapes[0]);
+    ov::test::utils::fill_data_random(tensor.data<int32_t>(), tensor.get_size(), 1024, -512);
+    inputs.insert({funcInput.get_node_shared_ptr(), tensor});
+}
+
 }  // namespace test
 }  // namespace ov