TST: finish removing tests that won't ever work

Author: ev-br

torch_np/tests/numpy_tests/core/test_dtype.py

@@ -4,15 +4,11 @@
 import types
 from typing import Any
 
-import numpy as np
-from numpy.testing import (
-    assert_, assert_equal, assert_array_equal, assert_raises)
-from numpy.compat import pickle
-
 import torch_np as np
 from torch_np.testing import (
-    assert_, assert_equal, assert_array_equal, assert_raises)
-#from numpy.compat import pickle
+    assert_, assert_equal, assert_array_equal)
+from pytest import raises as assert_raises
+
 
 import pickle
 from itertools import permutations
@@ -248,28 +244,13 @@ class TestPromotion:
     """Test cases related to more complex DType promotions.  Further promotion
     tests are defined in `test_numeric.py`
     """
-###    @np._no_nep50_warning()
     @pytest.mark.parametrize(["other", "expected", "expected_weak"],
             [(2**16-1, np.complex64, None),
              (2**32-1, np.complex128, np.complex64),
              (np.float16(2), np.complex64, None),
              (np.float32(2), np.complex64, None),
-             (np.longdouble(2), np.complex64, np.clongdouble),
-             # Base of the double value to sidestep any rounding issues:
-             (np.longdouble(np.nextafter(1.7e308, 0.)),
-                  np.complex128, np.clongdouble),
-             # Additionally use "nextafter" so the cast can't round down:
-             (np.longdouble(np.nextafter(1.7e308, np.inf)),
-                  np.clongdouble, None),
              # repeat for complex scalars:
              (np.complex64(2), np.complex64, None),
-             (np.clongdouble(2), np.complex64, np.clongdouble),
-             # Base of the double value to sidestep any rounding issues:
-             (np.clongdouble(np.nextafter(1.7e308, 0.) * 1j),
-                  np.complex128, np.clongdouble),
-             # Additionally use "nextafter" so the cast can't round down:
-             (np.clongdouble(np.nextafter(1.7e308, np.inf)),
-                  np.clongdouble, None),
              ])
     def test_complex_other_value_based(self,
             weak_promotion, other, expected, expected_weak):
@@ -318,8 +299,8 @@ def test_python_integer_promotion(self, val):
 
     @pytest.mark.parametrize(["dtypes", "expected"], [
              # These promotions are not associative/commutative:
-             ([np.uint16, np.int16, np.float16], np.float32),
-             ([np.uint16, np.int8, np.float16], np.float32),
+             ([np.int16, np.float16], np.float32),
+             ([np.int8, np.float16], np.float32),
              ([np.uint8, np.int16, np.float16], np.float32),
              # The following promotions are not ambiguous, but cover code
              # paths of abstract promotion (no particular logic being tested)

torch_np/tests/numpy_tests/core/test_scalar_ctors.py

@@ -8,14 +8,17 @@
     assert_equal, assert_almost_equal, assert_warns,
     )
 
+
 class TestFromString:
+    @pytest.mark.xfail(reason='XXX: floats from strings')
     def test_floating(self):
         # Ticket #640, floats from string
         fsingle = np.single('1.234')
         fdouble = np.double('1.234')
         assert_almost_equal(fsingle, 1.234)
         assert_almost_equal(fdouble, 1.234)
 
+    @pytest.mark.xfail(reason='XXX: floats from strings')
     def test_floating_overflow(self):
         """ Strings containing an unrepresentable float overflow """
         fhalf = np.half('1e10000')
@@ -32,7 +35,6 @@ def test_floating_overflow(self):
         fdouble = np.double('-1e10000')
         assert_equal(fdouble, -np.inf)
 
-
     def test_bool(self):
         with pytest.raises(TypeError):
             np.bool_(False, garbage=True)
@@ -44,8 +46,8 @@ def test_intp(self):
         assert_equal(1024, np.intp(1024))
 
     def test_uint64_from_negative(self):
-        with pytest.warns(DeprecationWarning):
-            assert_equal(np.uint64(-2), np.uint64(18446744073709551614))
+        # NumPy test was asserting a DeprecationWarning
+        assert_equal(np.uint8(-2), np.uint8(254))
 
 
 int_types = [np.byte, np.short, np.intc, np.int_, np.longlong]
@@ -66,6 +68,12 @@ def _do_test(self, t1, t2):
         else:
             assert arr.dtype.type is t2
 
+        arr1 = np.asarray(x, dtype=t2)
+        if t2 is None:
+            assert arr1.dtype.type is t1
+        else:
+            assert arr1.dtype.type is t2
+
     @pytest.mark.parametrize('t1', int_types + uint_types)
     @pytest.mark.parametrize('t2', int_types + uint_types + [None])
     def test_integers(self, t1, t2):

torch_np/tests/numpy_tests/core/test_scalar_methods.py

@@ -17,11 +17,12 @@
 from pytest import raises as assert_raises
 
 
+@pytest.mark.skip(reason='XXX: scalar.as_integer_ratio not implemented')
 class TestAsIntegerRatio:
     # derived in part from the cpython test "test_floatasratio"
 
     @pytest.mark.parametrize("ftype", [
-        np.half, np.single, np.double, np.longdouble])
+        np.half, np.single, np.double])
     @pytest.mark.parametrize("f, ratio", [
         (0.875, (7, 8)),
         (-0.875, (-7, 8)),
@@ -79,20 +80,6 @@ def test_against_known_values(self):
         (np.double, [0.0, 0.031066908499895136, 0.5214135908877832,
                      0.45780736035689296, 0.5906586745934036],
                     [0, -801, 51, 194, -653]),
-        pytest.param(
-            np.longdouble,
-            [0.0, 0.20492557202724854, 0.4277180662199366, 0.9888085019891495,
-             0.9620175814461964],
-            [0, -7400, 14266, -7822, -8721],
-            marks=[
-                pytest.mark.skipif(
-                    np.finfo(np.double) == np.finfo(np.longdouble),
-                    reason="long double is same as double"),
-                pytest.mark.skipif(
-                    platform.machine().startswith("ppc"),
-                    reason="IBM double double"),
-            ]
-        )
     ])
     def test_roundtrip(self, ftype, frac_vals, exp_vals):
         for frac, exp in zip(frac_vals, exp_vals):
@@ -136,6 +123,7 @@ def test_false(self, code: str) -> None:
             assert not value.is_integer()
 
 
+@pytest.mark.skip(reason='XXX: implementation details of the type system differ')
 @pytest.mark.skipif(sys.version_info < (3, 9), reason="Requires python 3.9")
 class TestClassGetItem:
     @pytest.mark.parametrize("cls", [
@@ -166,7 +154,7 @@ def test_abc_complexfloating_subscript_tuple(self, arg_len: int) -> None:
             with pytest.raises(TypeError, match=match):
                 np.complexfloating[arg_tup]
 
-    @pytest.mark.parametrize("cls", [np.generic, np.flexible, np.character])
+    @pytest.mark.parametrize("cls", [np.generic])
     def test_abc_non_numeric(self, cls: Type[np.generic]) -> None:
         with pytest.raises(TypeError):
             cls[Any]
@@ -198,6 +186,7 @@ def test_class_getitem_38(cls: Type[np.number]) -> None:
         cls[Any]
 
 
+@pytest.mark.skip(reason="scalartype(...).bit_count() not implemented")
 class TestBitCount:
     # derived in part from the cpython test "test_bit_count"
 

torch_np/tests/numpy_tests/core/test_scalarinherit.py

@@ -3,8 +3,9 @@
 """
 import pytest
 
-import numpy as np
-from numpy.testing import assert_, assert_raises
+import torch_np as np
+from torch_np.testing import assert_
+from pytest import raises as assert_raises
 
 
 class A:
@@ -30,6 +31,7 @@ class B1(np.float64, HasNew):
     pass
 
 
+@pytest.mark.xfail(reason='scalar repr: numpy plain to make more explicit')
 class TestInherit:
     def test_init(self):
         x = B(1.0)
@@ -54,45 +56,3 @@ def test_gh_15395(self):
         with pytest.raises(TypeError):
             B1(1.0, 2.0)
 
-
-class TestCharacter:
-    def test_char_radd(self):
-        # GH issue 9620, reached gentype_add and raise TypeError
-        np_s = np.string_('abc')
-        np_u = np.unicode_('abc')
-        s = b'def'
-        u = 'def'
-        assert_(np_s.__radd__(np_s) is NotImplemented)
-        assert_(np_s.__radd__(np_u) is NotImplemented)
-        assert_(np_s.__radd__(s) is NotImplemented)
-        assert_(np_s.__radd__(u) is NotImplemented)
-        assert_(np_u.__radd__(np_s) is NotImplemented)
-        assert_(np_u.__radd__(np_u) is NotImplemented)
-        assert_(np_u.__radd__(s) is NotImplemented)
-        assert_(np_u.__radd__(u) is NotImplemented)
-        assert_(s + np_s == b'defabc')
-        assert_(u + np_u == 'defabc')
-
-        class MyStr(str, np.generic):
-            # would segfault
-            pass
-
-        with assert_raises(TypeError):
-            # Previously worked, but gave completely wrong result
-            ret = s + MyStr('abc')
-
-        class MyBytes(bytes, np.generic):
-            # would segfault
-            pass
-
-        ret = s + MyBytes(b'abc')
-        assert(type(ret) is type(s))
-        assert ret == b"defabc"
-
-    def test_char_repeat(self):
-        np_s = np.string_('abc')
-        np_u = np.unicode_('abc')
-        res_s = b'abc' * 5
-        res_u = 'abc' * 5
-        assert_(np_s * 5 == res_s)
-        assert_(np_u * 5 == res_u)