Update test_solve

Author: vlad-perevezentsev

dpnp/tests/test_sycl_queue.py

@@ -2392,40 +2392,34 @@ def test_where(device):
     ids=[device.filter_string for device in valid_devices],
 )
 @pytest.mark.parametrize(
-    "matrix, vector",
+    "matrix, rhs",
     [
         ([[1, 2], [3, 5]], numpy.empty((2, 0))),
         ([[1, 2], [3, 5]], [1, 2]),
         (
             [
-                [[1, 1, 1], [0, 2, 5], [2, 5, -1]],
-                [[3, -1, 1], [1, 2, 3], [2, 3, 1]],
-                [[1, 4, 1], [1, 2, -2], [4, 1, 2]],
+                [[1, 1], [0, 2]],
+                [[3, -1], [1, 2]],
+            ],
+            [
+                [[6, -4], [9, -6]],
+                [[15, 1], [15, 1]],
             ],
-            [[6, -4, 27], [9, -6, 15], [15, 1, 11]],
         ),
     ],
     ids=[
-        "2D_Matrix_Empty_Vector",
-        "2D_Matrix_1D_Vector",
-        "3D_Matrix_and_Vectors",
+        "2D_Matrix_Empty_RHS",
+        "2D_Matrix_1D_RHS",
+        "3D_Matrix_and_3D_RHS",
     ],
 )
-def test_solve(matrix, vector, device):
+def test_solve(matrix, rhs, device):
     a_np = numpy.array(matrix)
-    b_np = numpy.array(vector)
+    b_np = numpy.array(rhs)
 
     a_dp = dpnp.array(a_np, device=device)
     b_dp = dpnp.array(b_np, device=device)
 
-    # In numpy 2.0 the broadcast ambiguity has been removed and now
-    # b is treaded as a single vector if and only if it is 1-dimensional;
-    # for other cases this signature must be followed
-    # (..., m, m), (..., m, n) -> (..., m, n)
-    # https://github.com/numpy/numpy/pull/25914
-    if a_dp.ndim > 2 and numpy.lib.NumpyVersion(numpy.__version__) >= "2.0.0":
-        pytest.skip("SAT-6928")
-
     result = dpnp.linalg.solve(a_dp, b_dp)
     expected = numpy.linalg.solve(a_np, b_np)
     assert_dtype_allclose(result, expected)

dpnp/tests/test_usm_type.py

@@ -1285,37 +1285,39 @@ def test_fftshift(self, func, usm_type):
     "usm_type_matrix", list_of_usm_types, ids=list_of_usm_types
 )
 @pytest.mark.parametrize(
-    "usm_type_vector", list_of_usm_types, ids=list_of_usm_types
+    "usm_type_rhs", list_of_usm_types, ids=list_of_usm_types
 )
 @pytest.mark.parametrize(
-    "matrix, vector",
+    "matrix, rhs",
     [
-        ([[1, 2], [3, 5]], dp.empty((2, 0))),
+        ([[1, 2], [3, 5]], numpy.empty((2, 0))),
         ([[1, 2], [3, 5]], [1, 2]),
         (
             [
-                [[1, 1, 1], [0, 2, 5], [2, 5, -1]],
-                [[3, -1, 1], [1, 2, 3], [2, 3, 1]],
-                [[1, 4, 1], [1, 2, -2], [4, 1, 2]],
+                [[1, 1], [0, 2]],
+                [[3, -1], [1, 2]],
+            ],
+            [
+                [[6, -4], [9, -6]],
+                [[15, 1], [15, 1]],
             ],
-            [[6, -4, 27], [9, -6, 15], [15, 1, 11]],
         ),
     ],
     ids=[
-        "2D_Matrix_Empty_Vector",
-        "2D_Matrix_1D_Vector",
-        "3D_Matrix_and_Vectors",
+        "2D_Matrix_Empty_RHS",
+        "2D_Matrix_1D_RHS",
+        "3D_Matrix_and_3D_RHS",
     ],
 )
-def test_solve(matrix, vector, usm_type_matrix, usm_type_vector):
+def test_solve(matrix, rhs, usm_type_matrix, usm_type_rhs):
     x = dp.array(matrix, usm_type=usm_type_matrix)
-    y = dp.array(vector, usm_type=usm_type_vector)
+    y = dp.array(rhs, usm_type=usm_type_rhs)
     z = dp.linalg.solve(x, y)
 
     assert x.usm_type == usm_type_matrix
-    assert y.usm_type == usm_type_vector
+    assert y.usm_type == usm_type_rhs
     assert z.usm_type == du.get_coerced_usm_type(
-        [usm_type_matrix, usm_type_vector]
+        [usm_type_matrix, usm_type_rhs]
     )