From 05addccefe7d0d46c8a369d7d9a76b74e7eb2601 Mon Sep 17 00:00:00 2001 From: Sergey Pokhodenko Date: Tue, 15 Dec 2020 04:59:37 -0600 Subject: [PATCH 1/6] Split tests for usmarray in separate unittest test cases --- numba_dppy/tests/test_usmarray.py | 333 ++++++++++++++++-------------- 1 file changed, 179 insertions(+), 154 deletions(-) diff --git a/numba_dppy/tests/test_usmarray.py b/numba_dppy/tests/test_usmarray.py index fe1be71c9e..e8cf1d4354 100644 --- a/numba_dppy/tests/test_usmarray.py +++ b/numba_dppy/tests/test_usmarray.py @@ -1,10 +1,11 @@ -from __future__ import print_function, division, absolute_import - import numba -import dpctl.dptensor.numpy_usm_shared as usmarray import numpy import sys +from numba_dppy.testing import DPPYTestCase + +import dpctl.dptensor.numpy_usm_shared as usmarray + def p1(a): return a * 2.0 + 13 @@ -75,154 +76,178 @@ def f12(x): # -------------------------------------------------------------------------------- -print("------------------- Testing Python Numpy") -sys.stdout.flush() -z1 = numpy.ones(10) -z2 = p1(z1) -print("z2:", z2, type(z2)) -assert type(z2) == numpy.ndarray - -print("------------------- Testing Numba Numpy") -sys.stdout.flush() -z1 = numpy.ones(10) -z2 = f1(z1) -print("z2:", z2, type(z2)) -assert type(z2) == numpy.ndarray - -print("------------------- Testing usmarray ones") -sys.stdout.flush() -a = usmarray.ones(10) -print("a:", a, type(a)) -assert isinstance(a, usmarray.ndarray) -assert usmarray.has_array_interface(a) - -print("------------------- Testing usmarray.usmarray.as_ndarray") -sys.stdout.flush() -nd1 = a.as_ndarray() -print("nd1:", nd1, type(nd1)) -assert type(nd1) == numpy.ndarray - -print("------------------- Testing usmarray.as_ndarray") -sys.stdout.flush() -nd2 = usmarray.as_ndarray(a) -print("nd2:", nd2, type(nd2)) -assert type(nd2) == numpy.ndarray - -print("------------------- Testing usmarray.from_ndarray") -sys.stdout.flush() -dp1 = usmarray.from_ndarray(nd2) -print("dp1:", dp1, type(dp1)) -assert isinstance(dp1, usmarray.ndarray) -assert usmarray.has_array_interface(dp1) - -print("------------------- Testing usmarray multiplication") -sys.stdout.flush() -c = a * 5 -print("c", c, type(c)) -assert isinstance(c, usmarray.ndarray) -assert usmarray.has_array_interface(c) - -print("------------------- Testing Python usmarray") -sys.stdout.flush() -b = p1(c) -print("b:", b, type(b)) -assert isinstance(b, usmarray.ndarray) -assert usmarray.has_array_interface(b) -del b - -print("------------------- Testing Python mixing usmarray and numpy.ndarray") -sys.stdout.flush() -h = p5(a, z1) -print("h:", h, type(h)) -assert isinstance(h, usmarray.ndarray) -assert usmarray.has_array_interface(h) -del h - -print("------------------- Testing Numba usmarray 2") -sys.stdout.flush() -d = f2(a) -print("d:", d, type(d)) -assert isinstance(d, usmarray.ndarray) -assert usmarray.has_array_interface(d) -del d - -print("------------------- Testing Numba usmarray") -sys.stdout.flush() -b = f1(c) -print("b:", b, type(b)) -assert isinstance(b, usmarray.ndarray) -assert usmarray.has_array_interface(b) -del b - -""" -print("------------------- Testing Numba usmarray constructor from numpy.ndarray") -sys.stdout.flush() -e = f3(a, z1) -print("e:", e, type(e)) -assert(isinstance(e, usmarray.ndarray)) -""" - -print("------------------- Testing Numba mixing usmarray and constant") -sys.stdout.flush() -g = f6(a) -print("g:", g, type(g)) -assert isinstance(g, usmarray.ndarray) -assert usmarray.has_array_interface(g) -del g - -print("------------------- Testing Numba mixing usmarray and numpy.ndarray") -sys.stdout.flush() -h = f5(a, z1) -print("h:", h, type(h)) -assert isinstance(h, usmarray.ndarray) -assert usmarray.has_array_interface(h) -del h - -print("------------------- Testing Numba usmarray functions") -sys.stdout.flush() -f = f4() -print("f:", f, type(f)) -assert isinstance(f, usmarray.ndarray) -assert usmarray.has_array_interface(f) -del f - -print("------------------- Testing Numba usmarray.as_ndarray") -sys.stdout.flush() -nd3 = f8(a) -print("nd3:", nd3, type(nd3)) -assert type(nd3) == numpy.ndarray - -print("------------------- Testing Numba usmarray.from_ndarray") -sys.stdout.flush() -dp2 = f9(nd3) -print("dp2:", dp2, type(dp2)) -assert isinstance(dp2, usmarray.ndarray) -assert usmarray.has_array_interface(dp2) -del nd3 -del dp2 - -print("------------------- Testing Numba usmarray.empty") -sys.stdout.flush() -dp3 = f10() -print("dp3:", dp3, type(dp3)) -assert isinstance(dp3, usmarray.ndarray) -assert usmarray.has_array_interface(dp3) - -print("------------------- Testing Numba usmarray.shape") -sys.stdout.flush() -s1 = f11(dp3) -print("s1:", s1, type(s1)) - -print("------------------- Testing Numba usmarray.T") -sys.stdout.flush() -dp4 = f12(dp3) -print("dp4:", dp4, type(dp4)) -assert isinstance(dp4, usmarray.ndarray) -assert usmarray.has_array_interface(dp4) -del dp3 -del dp4 - -# ------------------------------- -del a - -print("SUCCESS") + +class TestUsmArray(DPPYTestCase): + def setUp(self): + self.z1 = numpy.ones(10) + self.a = usmarray.ones(10) + self.nd2 = usmarray.as_ndarray(self.a) + self.c = self.a * 5 + self.nd3 = f8(self.a) + self.dp3 = f10() + + def test_python_numpy(self): + print("------------------- Testing Python Numpy") + sys.stdout.flush() + z2 = p1(self.z1) + print("z2:", z2, type(z2)) + assert type(z2) == numpy.ndarray + + def test_numba_numpy(self): + print("------------------- Testing Numba Numpy") + sys.stdout.flush() + z2 = f1(self.z1) + print("z2:", z2, type(z2)) + assert type(z2) == numpy.ndarray + + def test_usmarray_ones(self): + print("------------------- Testing usmarray ones") + sys.stdout.flush() + print("a:", self.a, type(self.a)) + assert isinstance(self.a, usmarray.ndarray) + assert usmarray.has_array_interface(self.a) + + def test_usmarray_usmarray_as_ndarray(self): + print("------------------- Testing usmarray.usmarray.as_ndarray") + sys.stdout.flush() + nd1 = self.a.as_ndarray() + print("nd1:", nd1, type(nd1)) + assert type(nd1) == numpy.ndarray + + def test_usmarray_as_ndarray(self): + print("------------------- Testing usmarray.as_ndarray") + sys.stdout.flush() + nd2 = usmarray.as_ndarray(self.a) + print("nd2:", nd2, type(nd2)) + assert type(nd2) == numpy.ndarray + + def test_usmarray_from_ndarray(self): + print("------------------- Testing usmarray.from_ndarray") + sys.stdout.flush() + dp1 = usmarray.from_ndarray(self.nd2) + print("dp1:", dp1, type(dp1)) + assert isinstance(dp1, usmarray.ndarray) + assert usmarray.has_array_interface(dp1) + + def test_usmarray_multiplication(self): + print("------------------- Testing usmarray multiplication") + sys.stdout.flush() + c = self.a * 5 + print("c", c, type(c)) + assert isinstance(c, usmarray.ndarray) + assert usmarray.has_array_interface(c) + + def test_python_usmarray(self): + print("------------------- Testing Python usmarray") + sys.stdout.flush() + b = p1(self.c) + print("b:", b, type(b)) + assert isinstance(b, usmarray.ndarray) + assert usmarray.has_array_interface(b) + del b + + def test_python_mixing_usmarray_and_numpy_ndarray(self): + print("------------------- Testing Python mixing usmarray and numpy.ndarray") + sys.stdout.flush() + h = p5(self.a, self.z1) + print("h:", h, type(h)) + assert isinstance(h, usmarray.ndarray) + assert usmarray.has_array_interface(h) + del h + + def test_numba_usmarray_2(self): + print("------------------- Testing Numba usmarray 2") + sys.stdout.flush() + d = f2(self.a) + print("d:", d, type(d)) + assert isinstance(d, usmarray.ndarray) + assert usmarray.has_array_interface(d) + del d + + def test_numba_usmarray(self): + # fails if run after test_all + + print("------------------- Testing Numba usmarray") + sys.stdout.flush() + b = f1(self.c) + print("b:", b, type(b)) + assert isinstance(b, usmarray.ndarray) + assert usmarray.has_array_interface(b) + del b + + def test_numba_usmarray_constructor_from_numpy_ndarray(self): + """ + print("------------------- Testing Numba usmarray constructor from numpy.ndarray") + sys.stdout.flush() + e = f3(self.a, self.z1) + print("e:", e, type(e)) + assert(isinstance(e, usmarray.ndarray)) + """ + + def test_numba_mixing_usmarray_and_constant(self): + print("------------------- Testing Numba mixing usmarray and constant") + sys.stdout.flush() + g = f6(self.a) + print("g:", g, type(g)) + assert isinstance(g, usmarray.ndarray) + assert usmarray.has_array_interface(g) + del g + + def test_numba_mixing_usmarray_and_numpy_ndarray(self): + print("------------------- Testing Numba mixing usmarray and numpy.ndarray") + sys.stdout.flush() + h = f5(self.a, self.z1) + print("h:", h, type(h)) + assert isinstance(h, usmarray.ndarray) + assert usmarray.has_array_interface(h) + del h + + def test_numba_usmarray_functions(self): + print("------------------- Testing Numba usmarray functions") + sys.stdout.flush() + f = f4() + print("f:", f, type(f)) + assert isinstance(f, usmarray.ndarray) + assert usmarray.has_array_interface(f) + del f + + def test_numba_usmarray_as_ndarray(self): + print("------------------- Testing Numba usmarray.as_ndarray") + sys.stdout.flush() + nd3 = f8(self.a) + print("nd3:", nd3, type(nd3)) + assert type(nd3) == numpy.ndarray + + def test_numba_usmarray_from_ndarray(self): + print("------------------- Testing Numba usmarray.from_ndarray") + sys.stdout.flush() + dp2 = f9(self.nd3) + print("dp2:", dp2, type(dp2)) + assert isinstance(dp2, usmarray.ndarray) + assert usmarray.has_array_interface(dp2) + del self.nd3 + del dp2 + + def test_numba_usmarray_empty(self): + print("------------------- Testing Numba usmarray.empty") + sys.stdout.flush() + dp3 = f10() + print("dp3:", dp3, type(dp3)) + assert isinstance(dp3, usmarray.ndarray) + assert usmarray.has_array_interface(dp3) + + def test_numba_usmarray_shape(self): + print("------------------- Testing Numba usmarray.shape") + sys.stdout.flush() + s1 = f11(self.dp3) + print("s1:", s1, type(s1)) + + def test_numba_usmarray_T(self): + print("------------------- Testing Numba usmarray.T") + sys.stdout.flush() + dp4 = f12(self.dp3) + print("dp4:", dp4, type(dp4)) + assert isinstance(dp4, usmarray.ndarray) + assert usmarray.has_array_interface(dp4) + del self.dp3 + del dp4 From bb628d78cf00d7424f6c545fe996b5b9964c3ab1 Mon Sep 17 00:00:00 2001 From: Sergey Pokhodenko Date: Tue, 15 Dec 2020 05:56:06 -0600 Subject: [PATCH 2/6] Remove prints and use unittest assertions --- numba_dppy/tests/test_usmarray.py | 163 +++++++++++------------------- 1 file changed, 57 insertions(+), 106 deletions(-) diff --git a/numba_dppy/tests/test_usmarray.py b/numba_dppy/tests/test_usmarray.py index e8cf1d4354..0aec8e7606 100644 --- a/numba_dppy/tests/test_usmarray.py +++ b/numba_dppy/tests/test_usmarray.py @@ -1,6 +1,7 @@ import numba import numpy import sys +import unittest from numba_dppy.testing import DPPYTestCase @@ -87,167 +88,117 @@ def setUp(self): self.dp3 = f10() def test_python_numpy(self): - print("------------------- Testing Python Numpy") - sys.stdout.flush() + """Testing Python Numpy""" z2 = p1(self.z1) - print("z2:", z2, type(z2)) - assert type(z2) == numpy.ndarray + self.assertEqual(type(z2), numpy.ndarray, z2) def test_numba_numpy(self): - print("------------------- Testing Numba Numpy") - sys.stdout.flush() + """Testing Numba Numpy""" z2 = f1(self.z1) - print("z2:", z2, type(z2)) - assert type(z2) == numpy.ndarray + self.assertEqual(type(z2), numpy.ndarray, z2) def test_usmarray_ones(self): - print("------------------- Testing usmarray ones") - sys.stdout.flush() - print("a:", self.a, type(self.a)) - assert isinstance(self.a, usmarray.ndarray) - assert usmarray.has_array_interface(self.a) + """Testing usmarray ones""" + a = usmarray.ones(10) + self.assertIsInstance(a, usmarray.ndarray, type(a)) + self.assertTrue(usmarray.has_array_interface(a)) def test_usmarray_usmarray_as_ndarray(self): - print("------------------- Testing usmarray.usmarray.as_ndarray") - sys.stdout.flush() + """Testing usmarray.usmarray.as_ndarray""" nd1 = self.a.as_ndarray() - print("nd1:", nd1, type(nd1)) - assert type(nd1) == numpy.ndarray + self.assertEqual(type(nd1), numpy.ndarray, nd1) def test_usmarray_as_ndarray(self): - print("------------------- Testing usmarray.as_ndarray") - sys.stdout.flush() + """Testing usmarray.as_ndarray""" nd2 = usmarray.as_ndarray(self.a) - print("nd2:", nd2, type(nd2)) - assert type(nd2) == numpy.ndarray + self.assertEqual(type(nd2), numpy.ndarray, nd2) def test_usmarray_from_ndarray(self): - print("------------------- Testing usmarray.from_ndarray") - sys.stdout.flush() + """Testing usmarray.from_ndarray""" dp1 = usmarray.from_ndarray(self.nd2) - print("dp1:", dp1, type(dp1)) - assert isinstance(dp1, usmarray.ndarray) - assert usmarray.has_array_interface(dp1) + self.assertIsInstance(dp1, usmarray.ndarray, type(dp1)) + self.assertTrue(usmarray.has_array_interface(dp1)) def test_usmarray_multiplication(self): - print("------------------- Testing usmarray multiplication") - sys.stdout.flush() + """Testing usmarray multiplication""" c = self.a * 5 - print("c", c, type(c)) - assert isinstance(c, usmarray.ndarray) - assert usmarray.has_array_interface(c) + self.assertIsInstance(c, usmarray.ndarray, type(c)) + self.assertTrue(usmarray.has_array_interface(c)) def test_python_usmarray(self): - print("------------------- Testing Python usmarray") - sys.stdout.flush() + """Testing Python usmarray""" b = p1(self.c) - print("b:", b, type(b)) - assert isinstance(b, usmarray.ndarray) - assert usmarray.has_array_interface(b) - del b + self.assertIsInstance(b, usmarray.ndarray, type(b)) + self.assertTrue(usmarray.has_array_interface(b)) def test_python_mixing_usmarray_and_numpy_ndarray(self): - print("------------------- Testing Python mixing usmarray and numpy.ndarray") - sys.stdout.flush() + """Testing Python mixing usmarray and numpy.ndarray""" h = p5(self.a, self.z1) - print("h:", h, type(h)) - assert isinstance(h, usmarray.ndarray) - assert usmarray.has_array_interface(h) - del h + self.assertIsInstance(h, usmarray.ndarray, type(h)) + self.assertTrue(usmarray.has_array_interface(h)) def test_numba_usmarray_2(self): - print("------------------- Testing Numba usmarray 2") - sys.stdout.flush() + """Testing Numba usmarray 2""" d = f2(self.a) - print("d:", d, type(d)) - assert isinstance(d, usmarray.ndarray) - assert usmarray.has_array_interface(d) - del d + self.assertIsInstance(d, usmarray.ndarray, type(d)) + self.assertTrue(usmarray.has_array_interface(d)) def test_numba_usmarray(self): + """Testing Numba usmarray""" # fails if run after test_all - - print("------------------- Testing Numba usmarray") - sys.stdout.flush() b = f1(self.c) - print("b:", b, type(b)) - assert isinstance(b, usmarray.ndarray) - assert usmarray.has_array_interface(b) - del b + self.assertIsInstance(b, usmarray.ndarray, type(b)) + self.assertTrue(usmarray.has_array_interface(b)) + @unittest.expectedFailure def test_numba_usmarray_constructor_from_numpy_ndarray(self): - """ - print("------------------- Testing Numba usmarray constructor from numpy.ndarray") - sys.stdout.flush() + """Testing Numba usmarray constructor from numpy.ndarray""" e = f3(self.a, self.z1) - print("e:", e, type(e)) - assert(isinstance(e, usmarray.ndarray)) - """ + self.assertIsInstance(e, usmarray.ndarray, type(e)) def test_numba_mixing_usmarray_and_constant(self): - print("------------------- Testing Numba mixing usmarray and constant") - sys.stdout.flush() + """Testing Numba mixing usmarray and constant""" g = f6(self.a) - print("g:", g, type(g)) - assert isinstance(g, usmarray.ndarray) - assert usmarray.has_array_interface(g) - del g + self.assertIsInstance(g, usmarray.ndarray, type(g)) + self.assertTrue(usmarray.has_array_interface(g)) def test_numba_mixing_usmarray_and_numpy_ndarray(self): - print("------------------- Testing Numba mixing usmarray and numpy.ndarray") - sys.stdout.flush() + """Testing Numba mixing usmarray and numpy.ndarray""" h = f5(self.a, self.z1) - print("h:", h, type(h)) - assert isinstance(h, usmarray.ndarray) - assert usmarray.has_array_interface(h) - del h + self.assertIsInstance(h, usmarray.ndarray, type(h)) + self.assertTrue(usmarray.has_array_interface(h)) def test_numba_usmarray_functions(self): - print("------------------- Testing Numba usmarray functions") - sys.stdout.flush() + """Testing Numba usmarray functions""" f = f4() - print("f:", f, type(f)) - assert isinstance(f, usmarray.ndarray) - assert usmarray.has_array_interface(f) - del f + self.assertIsInstance(f, usmarray.ndarray, type(f)) + self.assertTrue(usmarray.has_array_interface(f)) def test_numba_usmarray_as_ndarray(self): - print("------------------- Testing Numba usmarray.as_ndarray") - sys.stdout.flush() + """Testing Numba usmarray.as_ndarray""" nd3 = f8(self.a) - print("nd3:", nd3, type(nd3)) - assert type(nd3) == numpy.ndarray + self.assertEqual(type(nd3), numpy.ndarray, nd3) def test_numba_usmarray_from_ndarray(self): - print("------------------- Testing Numba usmarray.from_ndarray") - sys.stdout.flush() + """Testing Numba usmarray.from_ndarray""" dp2 = f9(self.nd3) - print("dp2:", dp2, type(dp2)) - assert isinstance(dp2, usmarray.ndarray) - assert usmarray.has_array_interface(dp2) - del self.nd3 - del dp2 + self.assertIsInstance(dp2, usmarray.ndarray, type(dp2)) + self.assertTrue(usmarray.has_array_interface(dp2)) def test_numba_usmarray_empty(self): - print("------------------- Testing Numba usmarray.empty") - sys.stdout.flush() + """Testing Numba usmarray.empty""" dp3 = f10() - print("dp3:", dp3, type(dp3)) - assert isinstance(dp3, usmarray.ndarray) - assert usmarray.has_array_interface(dp3) + self.assertIsInstance(dp3, usmarray.ndarray, type(dp3)) + self.assertTrue(usmarray.has_array_interface(dp3)) def test_numba_usmarray_shape(self): - print("------------------- Testing Numba usmarray.shape") - sys.stdout.flush() + """Testing Numba usmarray.shape""" s1 = f11(self.dp3) - print("s1:", s1, type(s1)) + self.assertIsInstance(s1, tuple, type(s1)) + self.assertEqual(s1, (10, 10)) def test_numba_usmarray_T(self): - print("------------------- Testing Numba usmarray.T") - sys.stdout.flush() + """Testing Numba usmarray.T""" dp4 = f12(self.dp3) - print("dp4:", dp4, type(dp4)) - assert isinstance(dp4, usmarray.ndarray) - assert usmarray.has_array_interface(dp4) - del self.dp3 - del dp4 + self.assertIsInstance(dp4, usmarray.ndarray, type(dp4)) + self.assertTrue(usmarray.has_array_interface(dp4)) From 5bd101b756d7096774072fb7f87b22b6dc0d42c6 Mon Sep 17 00:00:00 2001 From: Sergey Pokhodenko Date: Tue, 15 Dec 2020 06:13:19 -0600 Subject: [PATCH 3/6] Move functions to tests --- numba_dppy/tests/test_usmarray.py | 73 +++++++++++++++---------------- 1 file changed, 35 insertions(+), 38 deletions(-) diff --git a/numba_dppy/tests/test_usmarray.py b/numba_dppy/tests/test_usmarray.py index 0aec8e7606..3dad25866c 100644 --- a/numba_dppy/tests/test_usmarray.py +++ b/numba_dppy/tests/test_usmarray.py @@ -15,21 +15,6 @@ def p1(a): f1 = numba.njit(p1) -@numba.njit() -def f2(a): - return a - - -@numba.njit() -def f3(a, b): # a is usmarray, b is numpy - return a * usmarray.asarray(b) - - -@numba.njit() -def f4(): - return usmarray.ones(10) - - def p5(a, b): # a is usmarray, b is numpy return a * b @@ -37,11 +22,6 @@ def p5(a, b): # a is usmarray, b is numpy f5 = numba.njit(p5) -@numba.njit() -def f6(a): - return a + 13 - - @numba.njit() def f7(a): # a is usmarray # implicit conversion of a to numpy.ndarray @@ -55,29 +35,11 @@ def f8(a): return usmarray.as_ndarray(a) -@numba.njit -def f9(a): - return usmarray.from_ndarray(a) - - @numba.njit def f10(): return usmarray.empty((10, 10)) -@numba.njit -def f11(x): - return x.shape - - -@numba.njit -def f12(x): - return x.T - - -# -------------------------------------------------------------------------------- - - class TestUsmArray(DPPYTestCase): def setUp(self): self.z1 = numpy.ones(10) @@ -139,6 +101,11 @@ def test_python_mixing_usmarray_and_numpy_ndarray(self): def test_numba_usmarray_2(self): """Testing Numba usmarray 2""" + + @numba.njit() + def f2(a): + return a + d = f2(self.a) self.assertIsInstance(d, usmarray.ndarray, type(d)) self.assertTrue(usmarray.has_array_interface(d)) @@ -153,11 +120,21 @@ def test_numba_usmarray(self): @unittest.expectedFailure def test_numba_usmarray_constructor_from_numpy_ndarray(self): """Testing Numba usmarray constructor from numpy.ndarray""" + + @numba.njit() + def f3(a, b): # a is usmarray, b is numpy + return a * usmarray.asarray(b) + e = f3(self.a, self.z1) self.assertIsInstance(e, usmarray.ndarray, type(e)) def test_numba_mixing_usmarray_and_constant(self): """Testing Numba mixing usmarray and constant""" + + @numba.njit() + def f6(a): + return a + 13 + g = f6(self.a) self.assertIsInstance(g, usmarray.ndarray, type(g)) self.assertTrue(usmarray.has_array_interface(g)) @@ -170,6 +147,11 @@ def test_numba_mixing_usmarray_and_numpy_ndarray(self): def test_numba_usmarray_functions(self): """Testing Numba usmarray functions""" + + @numba.njit() + def f4(): + return usmarray.ones(10) + f = f4() self.assertIsInstance(f, usmarray.ndarray, type(f)) self.assertTrue(usmarray.has_array_interface(f)) @@ -181,6 +163,11 @@ def test_numba_usmarray_as_ndarray(self): def test_numba_usmarray_from_ndarray(self): """Testing Numba usmarray.from_ndarray""" + + @numba.njit + def f9(a): + return usmarray.from_ndarray(a) + dp2 = f9(self.nd3) self.assertIsInstance(dp2, usmarray.ndarray, type(dp2)) self.assertTrue(usmarray.has_array_interface(dp2)) @@ -193,12 +180,22 @@ def test_numba_usmarray_empty(self): def test_numba_usmarray_shape(self): """Testing Numba usmarray.shape""" + + @numba.njit + def f11(x): + return x.shape + s1 = f11(self.dp3) self.assertIsInstance(s1, tuple, type(s1)) self.assertEqual(s1, (10, 10)) def test_numba_usmarray_T(self): """Testing Numba usmarray.T""" + + @numba.njit + def f12(x): + return x.T + dp4 = f12(self.dp3) self.assertIsInstance(dp4, usmarray.ndarray, type(dp4)) self.assertTrue(usmarray.has_array_interface(dp4)) From bedbafc5371921906885d14bc62c0abcf05e96f0 Mon Sep 17 00:00:00 2001 From: Sergey Pokhodenko Date: Tue, 15 Dec 2020 07:23:32 -0600 Subject: [PATCH 4/6] Give names to functions --- numba_dppy/tests/test_usmarray.py | 159 +++++++++++++++--------------- 1 file changed, 80 insertions(+), 79 deletions(-) diff --git a/numba_dppy/tests/test_usmarray.py b/numba_dppy/tests/test_usmarray.py index 3dad25866c..ee4652762f 100644 --- a/numba_dppy/tests/test_usmarray.py +++ b/numba_dppy/tests/test_usmarray.py @@ -8,55 +8,86 @@ import dpctl.dptensor.numpy_usm_shared as usmarray -def p1(a): +@numba.njit() +def numba_mul_add(a): return a * 2.0 + 13 -f1 = numba.njit(p1) +@numba.njit() +def numba_add_const(a): + return a + 13 -def p5(a, b): # a is usmarray, b is numpy +@numba.njit() +def numba_mul(a, b): # a is usmarray, b is numpy return a * b -f5 = numba.njit(p5) +@numba.njit() +def numba_mul_usmarray_asarray(a, b): # a is usmarray, b is numpy + return a * usmarray.asarray(b) -@numba.njit() -def f7(a): # a is usmarray - # implicit conversion of a to numpy.ndarray - b = numpy.ones(10) - c = a * b - d = a.argsort() # with no implicit conversion this fails +# @numba.njit() +# def f7(a): # a is usmarray +# # implicit conversion of a to numpy.ndarray +# b = numpy.ones(10) +# c = a * b +# d = a.argsort() # with no implicit conversion this fails @numba.njit -def f8(a): +def numba_usmarray_as_ndarray(a): return usmarray.as_ndarray(a) @numba.njit -def f10(): +def numba_usmarray_from_ndarray(a): + return usmarray.from_ndarray(a) + + +@numba.njit() +def numba_usmarray_ones(): + return usmarray.ones(10) + + +@numba.njit +def numba_usmarray_empty(): return usmarray.empty((10, 10)) +@numba.njit() +def numba_identity(a): + return a + + +@numba.njit +def numba_shape(x): + return x.shape + + +@numba.njit +def numba_T(x): + return x.T + + class TestUsmArray(DPPYTestCase): - def setUp(self): - self.z1 = numpy.ones(10) - self.a = usmarray.ones(10) - self.nd2 = usmarray.as_ndarray(self.a) - self.c = self.a * 5 - self.nd3 = f8(self.a) - self.dp3 = f10() + def ndarray(self): + """Create NumPy array""" + return numpy.ones(10) + + def usmarray(self): + """Create dpCtl USM array""" + return usmarray.ones(10) def test_python_numpy(self): """Testing Python Numpy""" - z2 = p1(self.z1) + z2 = numba_mul_add.py_func(self.ndarray()) self.assertEqual(type(z2), numpy.ndarray, z2) def test_numba_numpy(self): """Testing Numba Numpy""" - z2 = f1(self.z1) + z2 = numba_mul_add(self.ndarray()) self.assertEqual(type(z2), numpy.ndarray, z2) def test_usmarray_ones(self): @@ -67,135 +98,105 @@ def test_usmarray_ones(self): def test_usmarray_usmarray_as_ndarray(self): """Testing usmarray.usmarray.as_ndarray""" - nd1 = self.a.as_ndarray() + nd1 = self.usmarray().as_ndarray() self.assertEqual(type(nd1), numpy.ndarray, nd1) def test_usmarray_as_ndarray(self): """Testing usmarray.as_ndarray""" - nd2 = usmarray.as_ndarray(self.a) + nd2 = usmarray.as_ndarray(self.usmarray()) self.assertEqual(type(nd2), numpy.ndarray, nd2) def test_usmarray_from_ndarray(self): """Testing usmarray.from_ndarray""" - dp1 = usmarray.from_ndarray(self.nd2) + nd2 = usmarray.as_ndarray(self.usmarray()) + dp1 = usmarray.from_ndarray(nd2) self.assertIsInstance(dp1, usmarray.ndarray, type(dp1)) self.assertTrue(usmarray.has_array_interface(dp1)) def test_usmarray_multiplication(self): """Testing usmarray multiplication""" - c = self.a * 5 + c = self.usmarray() * 5 self.assertIsInstance(c, usmarray.ndarray, type(c)) self.assertTrue(usmarray.has_array_interface(c)) - def test_python_usmarray(self): + def test_python_usmarray_mul_add(self): """Testing Python usmarray""" - b = p1(self.c) + c = self.usmarray() * 5 + b = numba_mul_add.py_func(c) + self.assertIsInstance(b, usmarray.ndarray, type(b)) + self.assertTrue(usmarray.has_array_interface(b)) + + def test_numba_usmarray_mul_add(self): + """Testing Numba usmarray""" + # fails if run tests in bunch + c = self.usmarray() * 5 + b = numba_mul_add(c) self.assertIsInstance(b, usmarray.ndarray, type(b)) self.assertTrue(usmarray.has_array_interface(b)) def test_python_mixing_usmarray_and_numpy_ndarray(self): """Testing Python mixing usmarray and numpy.ndarray""" - h = p5(self.a, self.z1) + h = numba_mul.py_func(self.usmarray(), self.ndarray()) self.assertIsInstance(h, usmarray.ndarray, type(h)) self.assertTrue(usmarray.has_array_interface(h)) def test_numba_usmarray_2(self): """Testing Numba usmarray 2""" - @numba.njit() - def f2(a): - return a - - d = f2(self.a) + d = numba_identity(self.usmarray()) self.assertIsInstance(d, usmarray.ndarray, type(d)) self.assertTrue(usmarray.has_array_interface(d)) - def test_numba_usmarray(self): - """Testing Numba usmarray""" - # fails if run after test_all - b = f1(self.c) - self.assertIsInstance(b, usmarray.ndarray, type(b)) - self.assertTrue(usmarray.has_array_interface(b)) - @unittest.expectedFailure def test_numba_usmarray_constructor_from_numpy_ndarray(self): """Testing Numba usmarray constructor from numpy.ndarray""" - - @numba.njit() - def f3(a, b): # a is usmarray, b is numpy - return a * usmarray.asarray(b) - - e = f3(self.a, self.z1) + e = numba_mul_usmarray_asarray(self.usmarray(), self.ndarray()) self.assertIsInstance(e, usmarray.ndarray, type(e)) def test_numba_mixing_usmarray_and_constant(self): """Testing Numba mixing usmarray and constant""" - - @numba.njit() - def f6(a): - return a + 13 - - g = f6(self.a) + g = numba_add_const(self.usmarray()) self.assertIsInstance(g, usmarray.ndarray, type(g)) self.assertTrue(usmarray.has_array_interface(g)) def test_numba_mixing_usmarray_and_numpy_ndarray(self): """Testing Numba mixing usmarray and numpy.ndarray""" - h = f5(self.a, self.z1) + h = numba_mul(self.usmarray(), self.ndarray()) self.assertIsInstance(h, usmarray.ndarray, type(h)) self.assertTrue(usmarray.has_array_interface(h)) def test_numba_usmarray_functions(self): """Testing Numba usmarray functions""" - - @numba.njit() - def f4(): - return usmarray.ones(10) - - f = f4() + f = numba_usmarray_ones() self.assertIsInstance(f, usmarray.ndarray, type(f)) self.assertTrue(usmarray.has_array_interface(f)) def test_numba_usmarray_as_ndarray(self): """Testing Numba usmarray.as_ndarray""" - nd3 = f8(self.a) + nd3 = numba_usmarray_as_ndarray(self.usmarray()) self.assertEqual(type(nd3), numpy.ndarray, nd3) def test_numba_usmarray_from_ndarray(self): """Testing Numba usmarray.from_ndarray""" - - @numba.njit - def f9(a): - return usmarray.from_ndarray(a) - - dp2 = f9(self.nd3) + nd3 = numba_usmarray_as_ndarray(self.usmarray()) + dp2 = numba_usmarray_from_ndarray(nd3) self.assertIsInstance(dp2, usmarray.ndarray, type(dp2)) self.assertTrue(usmarray.has_array_interface(dp2)) def test_numba_usmarray_empty(self): """Testing Numba usmarray.empty""" - dp3 = f10() + dp3 = numba_usmarray_empty() self.assertIsInstance(dp3, usmarray.ndarray, type(dp3)) self.assertTrue(usmarray.has_array_interface(dp3)) def test_numba_usmarray_shape(self): """Testing Numba usmarray.shape""" - - @numba.njit - def f11(x): - return x.shape - - s1 = f11(self.dp3) + s1 = numba_shape(numba_usmarray_empty()) self.assertIsInstance(s1, tuple, type(s1)) self.assertEqual(s1, (10, 10)) def test_numba_usmarray_T(self): """Testing Numba usmarray.T""" - - @numba.njit - def f12(x): - return x.T - - dp4 = f12(self.dp3) + dp4 = numba_T(numba_usmarray_empty()) self.assertIsInstance(dp4, usmarray.ndarray, type(dp4)) self.assertTrue(usmarray.has_array_interface(dp4)) From 80d2566c3621bddefca2912c7dcc33997c6cbb01 Mon Sep 17 00:00:00 2001 From: Sergey Pokhodenko Date: Tue, 15 Dec 2020 07:23:57 -0600 Subject: [PATCH 5/6] Add expectedFailure for failed tests --- numba_dppy/tests/test_usmarray.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/numba_dppy/tests/test_usmarray.py b/numba_dppy/tests/test_usmarray.py index ee4652762f..8e483535e6 100644 --- a/numba_dppy/tests/test_usmarray.py +++ b/numba_dppy/tests/test_usmarray.py @@ -126,6 +126,7 @@ def test_python_usmarray_mul_add(self): self.assertIsInstance(b, usmarray.ndarray, type(b)) self.assertTrue(usmarray.has_array_interface(b)) + @unittest.expectedFailure def test_numba_usmarray_mul_add(self): """Testing Numba usmarray""" # fails if run tests in bunch @@ -195,6 +196,7 @@ def test_numba_usmarray_shape(self): self.assertIsInstance(s1, tuple, type(s1)) self.assertEqual(s1, (10, 10)) + @unittest.expectedFailure def test_numba_usmarray_T(self): """Testing Numba usmarray.T""" dp4 = numba_T(numba_usmarray_empty()) From e401810d637b8fb33b699b5e8e93a9e3cf2d020c Mon Sep 17 00:00:00 2001 From: Sergey Pokhodenko Date: Tue, 15 Dec 2020 07:27:21 -0600 Subject: [PATCH 6/6] Clean code --- numba_dppy/tests/test_usmarray.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/numba_dppy/tests/test_usmarray.py b/numba_dppy/tests/test_usmarray.py index 8e483535e6..6ee21ab3da 100644 --- a/numba_dppy/tests/test_usmarray.py +++ b/numba_dppy/tests/test_usmarray.py @@ -1,12 +1,11 @@ import numba import numpy -import sys import unittest -from numba_dppy.testing import DPPYTestCase - import dpctl.dptensor.numpy_usm_shared as usmarray +from numba_dppy.testing import DPPYTestCase + @numba.njit() def numba_mul_add(a):