TST: Replace xunit setup with methods (#29605)

bwhitt7 · web-flow · commit 1aa051052ca0 · 2025-08-22T10:05:07.000-06:00
diff --git a/numpy/_core/tests/test_half.py b/numpy/_core/tests/test_half.py
@@ -18,56 +18,63 @@ def assert_raises_fpe(strmatch, callable, *args, **kwargs):
                 f"Did not raise floating point {strmatch} error")
 
 class TestHalf:
-    def setup_method(self):
+    def _create_arrays_all(self):
         # An array of all possible float16 values
-        self.all_f16 = np.arange(0x10000, dtype=uint16)
-        self.all_f16 = self.all_f16.view(float16)
+        all_f16 = np.arange(0x10000, dtype=uint16)
+        all_f16 = all_f16.view(float16)
 
         # NaN value can cause an invalid FP exception if HW is being used
         with np.errstate(invalid='ignore'):
-            self.all_f32 = np.array(self.all_f16, dtype=float32)
-            self.all_f64 = np.array(self.all_f16, dtype=float64)
+            all_f32 = np.array(all_f16, dtype=float32)
+            all_f64 = np.array(all_f16, dtype=float64)
+        return all_f16, all_f32, all_f64
 
+    def _create_arrays_nonan(self):
         # An array of all non-NaN float16 values, in sorted order
-        self.nonan_f16 = np.concatenate(
+        nonan_f16 = np.concatenate(
                                 (np.arange(0xfc00, 0x7fff, -1, dtype=uint16),
                                  np.arange(0x0000, 0x7c01, 1, dtype=uint16)))
-        self.nonan_f16 = self.nonan_f16.view(float16)
-        self.nonan_f32 = np.array(self.nonan_f16, dtype=float32)
-        self.nonan_f64 = np.array(self.nonan_f16, dtype=float64)
-
-        # An array of all finite float16 values, in sorted order
-        self.finite_f16 = self.nonan_f16[1:-1]
-        self.finite_f32 = self.nonan_f32[1:-1]
-        self.finite_f64 = self.nonan_f64[1:-1]
+        nonan_f16 = nonan_f16.view(float16)
+        nonan_f32 = np.array(nonan_f16, dtype=float32)
+        nonan_f64 = np.array(nonan_f16, dtype=float64)
+        return nonan_f16, nonan_f32, nonan_f64
+
+    def _create_arrays_finite(self):
+        nonan_f16, nonan_f32, nonan_f64 = self._create_arrays_nonan()
+        finite_f16 = nonan_f16[1:-1]
+        finite_f32 = nonan_f32[1:-1]
+        finite_f64 = nonan_f64[1:-1]
+        return finite_f16, finite_f32, finite_f64
 
     def test_half_conversions(self):
         """Checks that all 16-bit values survive conversion
            to/from 32-bit and 64-bit float"""
         # Because the underlying routines preserve the NaN bits, every
         # value is preserved when converting to/from other floats.
+        all_f16, all_f32, all_f64 = self._create_arrays_all()
+        nonan_f16, _, _ = self._create_arrays_nonan()
 
         # Convert from float32 back to float16
         with np.errstate(invalid='ignore'):
-            b = np.array(self.all_f32, dtype=float16)
+            b = np.array(all_f32, dtype=float16)
         # avoid testing NaNs due to differing bit patterns in Q/S NaNs
         b_nn = b == b
-        assert_equal(self.all_f16[b_nn].view(dtype=uint16),
+        assert_equal(all_f16[b_nn].view(dtype=uint16),
                      b[b_nn].view(dtype=uint16))
 
         # Convert from float64 back to float16
         with np.errstate(invalid='ignore'):
-            b = np.array(self.all_f64, dtype=float16)
+            b = np.array(all_f64, dtype=float16)
         b_nn = b == b
-        assert_equal(self.all_f16[b_nn].view(dtype=uint16),
+        assert_equal(all_f16[b_nn].view(dtype=uint16),
                      b[b_nn].view(dtype=uint16))
 
         # Convert float16 to longdouble and back
         # This doesn't necessarily preserve the extra NaN bits,
         # so exclude NaNs.
-        a_ld = np.array(self.nonan_f16, dtype=np.longdouble)
+        a_ld = np.array(nonan_f16, dtype=np.longdouble)
         b = np.array(a_ld, dtype=float16)
-        assert_equal(self.nonan_f16.view(dtype=uint16),
+        assert_equal(nonan_f16.view(dtype=uint16),
                      b.view(dtype=uint16))
 
         # Check the range for which all integers can be represented
@@ -171,34 +178,35 @@ def test_half_conversion_denormal_round_even(self, float_t, uint_t, bits):
             assert larger_value.astype(np.float16) == smallest_value
 
     def test_nans_infs(self):
+        all_f16, all_f32, _ = self._create_arrays_all()
         with np.errstate(all='ignore'):
             # Check some of the ufuncs
-            assert_equal(np.isnan(self.all_f16), np.isnan(self.all_f32))
-            assert_equal(np.isinf(self.all_f16), np.isinf(self.all_f32))
-            assert_equal(np.isfinite(self.all_f16), np.isfinite(self.all_f32))
-            assert_equal(np.signbit(self.all_f16), np.signbit(self.all_f32))
+            assert_equal(np.isnan(all_f16), np.isnan(all_f32))
+            assert_equal(np.isinf(all_f16), np.isinf(all_f32))
+            assert_equal(np.isfinite(all_f16), np.isfinite(all_f32))
+            assert_equal(np.signbit(all_f16), np.signbit(all_f32))
             assert_equal(np.spacing(float16(65504)), np.inf)
 
             # Check comparisons of all values with NaN
             nan = float16(np.nan)
 
-            assert_(not (self.all_f16 == nan).any())
-            assert_(not (nan == self.all_f16).any())
+            assert_(not (all_f16 == nan).any())
+            assert_(not (nan == all_f16).any())
 
-            assert_((self.all_f16 != nan).all())
-            assert_((nan != self.all_f16).all())
+            assert_((all_f16 != nan).all())
+            assert_((nan != all_f16).all())
 
-            assert_(not (self.all_f16 < nan).any())
-            assert_(not (nan < self.all_f16).any())
+            assert_(not (all_f16 < nan).any())
+            assert_(not (nan < all_f16).any())
 
-            assert_(not (self.all_f16 <= nan).any())
-            assert_(not (nan <= self.all_f16).any())
+            assert_(not (all_f16 <= nan).any())
+            assert_(not (nan <= all_f16).any())
 
-            assert_(not (self.all_f16 > nan).any())
-            assert_(not (nan > self.all_f16).any())
+            assert_(not (all_f16 > nan).any())
+            assert_(not (nan > all_f16).any())
 
-            assert_(not (self.all_f16 >= nan).any())
-            assert_(not (nan >= self.all_f16).any())
+            assert_(not (all_f16 >= nan).any())
+            assert_(not (nan >= all_f16).any())
 
     def test_half_values(self):
         """Confirms a small number of known half values"""
@@ -255,9 +263,10 @@ def test_half_rounding(self):
     def test_half_correctness(self):
         """Take every finite float16, and check the casting functions with
            a manual conversion."""
+        finite_f16, finite_f32, finite_f64 = self._create_arrays_finite()
 
         # Create an array of all finite float16s
-        a_bits = self.finite_f16.view(dtype=uint16)
+        a_bits = finite_f16.view(dtype=uint16)
 
         # Convert to 64-bit float manually
         a_sgn = (-1.0)**((a_bits & 0x8000) >> 15)
@@ -270,29 +279,30 @@ def test_half_correctness(self):
 
         a_manual = a_sgn * a_man * 2.0**a_exp
 
-        a32_fail = np.nonzero(self.finite_f32 != a_manual)[0]
+        a32_fail = np.nonzero(finite_f32 != a_manual)[0]
         if len(a32_fail) != 0:
             bad_index = a32_fail[0]
-            assert_equal(self.finite_f32, a_manual,
+            assert_equal(finite_f32, a_manual,
                  "First non-equal is half value 0x%x -> %g != %g" %
                             (a_bits[bad_index],
-                             self.finite_f32[bad_index],
+                             finite_f32[bad_index],
                              a_manual[bad_index]))
 
-        a64_fail = np.nonzero(self.finite_f64 != a_manual)[0]
+        a64_fail = np.nonzero(finite_f64 != a_manual)[0]
         if len(a64_fail) != 0:
             bad_index = a64_fail[0]
-            assert_equal(self.finite_f64, a_manual,
+            assert_equal(finite_f64, a_manual,
                  "First non-equal is half value 0x%x -> %g != %g" %
                             (a_bits[bad_index],
-                             self.finite_f64[bad_index],
+                             finite_f64[bad_index],
                              a_manual[bad_index]))
 
     def test_half_ordering(self):
         """Make sure comparisons are working right"""
+        nonan_f16, _, _ = self._create_arrays_nonan()
 
         # All non-NaN float16 values in reverse order
-        a = self.nonan_f16[::-1].copy()
+        a = nonan_f16[::-1].copy()
 
         # 32-bit float copy
         b = np.array(a, dtype=float32)
diff --git a/numpy/_core/tests/test_indexing.py b/numpy/_core/tests/test_indexing.py
@@ -776,6 +776,7 @@ def test_boolean_index_cast_assign(self):
                      zero_array.__setitem__, bool_index, np.array([1j]))
         assert_equal(zero_array[0, 1], 0)
 
+
 class TestFancyIndexingEquivalence:
     def test_object_assign(self):
         # Check that the field and object special case using copyto is active.
@@ -846,10 +847,11 @@ class TestMultiIndexingAutomated:
 
     """
 
-    def setup_method(self):
-        self.a = np.arange(np.prod([3, 1, 5, 6])).reshape(3, 1, 5, 6)
-        self.b = np.empty((3, 0, 5, 6))
-        self.complex_indices = ['skip', Ellipsis,
+    def _create_array(self):
+        return np.arange(np.prod([3, 1, 5, 6])).reshape(3, 1, 5, 6)
+
+    def _create_complex_indices(self):
+        return ['skip', Ellipsis,
             0,
             # Boolean indices, up to 3-d for some special cases of eating up
             # dimensions, also need to test all False
@@ -869,11 +871,6 @@ def setup_method(self):
             np.array([2, -1], dtype=np.int8),
             np.zeros([1] * 31, dtype=int),  # trigger too large array.
             np.array([0., 1.])]  # invalid datatype
-        # Some simpler indices that still cover a bit more
-        self.simple_indices = [Ellipsis, None, -1, [1], np.array([True]),
-                               'skip']
-        # Very simple ones to fill the rest:
-        self.fill_indices = [slice(None, None), 0]
 
     def _get_multi_index(self, arr, indices):
         """Mimic multi dimensional indexing.
@@ -1206,16 +1203,23 @@ def test_boolean(self):
         # it is aligned to the left. This is probably correct for
         # consistency with arr[boolean_array,] also no broadcasting
         # is done at all
+        a = self._create_array()
         self._check_multi_index(
-            self.a, (np.zeros_like(self.a, dtype=bool),))
+            a, (np.zeros_like(a, dtype=bool),))
         self._check_multi_index(
-            self.a, (np.zeros_like(self.a, dtype=bool)[..., 0],))
+            a, (np.zeros_like(a, dtype=bool)[..., 0],))
         self._check_multi_index(
-            self.a, (np.zeros_like(self.a, dtype=bool)[None, ...],))
+            a, (np.zeros_like(a, dtype=bool)[None, ...],))
 
     def test_multidim(self):
         # Automatically test combinations with complex indexes on 2nd (or 1st)
         # spot and the simple ones in one other spot.
+        a = self._create_array()
+        b = np.empty((3, 0, 5, 6))
+        complex_indices = self._create_complex_indices()
+        simple_indices = [Ellipsis, None, -1, [1], np.array([True]), 'skip']
+        fill_indices = [slice(None, None), 0]
+
         with warnings.catch_warnings():
             # This is so that np.array(True) is not accepted in a full integer
             # index, when running the file separately.
@@ -1226,28 +1230,30 @@ def isskip(idx):
                 return isinstance(idx, str) and idx == "skip"
 
             for simple_pos in [0, 2, 3]:
-                tocheck = [self.fill_indices, self.complex_indices,
-                           self.fill_indices, self.fill_indices]
-                tocheck[simple_pos] = self.simple_indices
+                tocheck = [fill_indices, complex_indices,
+                           fill_indices, fill_indices]
+                tocheck[simple_pos] = simple_indices
                 for index in product(*tocheck):
                     index = tuple(i for i in index if not isskip(i))
-                    self._check_multi_index(self.a, index)
-                    self._check_multi_index(self.b, index)
+                    self._check_multi_index(a, index)
+                    self._check_multi_index(b, index)
 
         # Check very simple item getting:
-        self._check_multi_index(self.a, (0, 0, 0, 0))
-        self._check_multi_index(self.b, (0, 0, 0, 0))
+        self._check_multi_index(a, (0, 0, 0, 0))
+        self._check_multi_index(b, (0, 0, 0, 0))
         # Also check (simple cases of) too many indices:
-        assert_raises(IndexError, self.a.__getitem__, (0, 0, 0, 0, 0))
-        assert_raises(IndexError, self.a.__setitem__, (0, 0, 0, 0, 0), 0)
-        assert_raises(IndexError, self.a.__getitem__, (0, 0, [1], 0, 0))
-        assert_raises(IndexError, self.a.__setitem__, (0, 0, [1], 0, 0), 0)
+        assert_raises(IndexError, a.__getitem__, (0, 0, 0, 0, 0))
+        assert_raises(IndexError, a.__setitem__, (0, 0, 0, 0, 0), 0)
+        assert_raises(IndexError, a.__getitem__, (0, 0, [1], 0, 0))
+        assert_raises(IndexError, a.__setitem__, (0, 0, [1], 0, 0), 0)
 
     def test_1d(self):
         a = np.arange(10)
-        for index in self.complex_indices:
+        complex_indices = self._create_complex_indices()
+        for index in complex_indices:
             self._check_single_index(a, index)
 
+
 class TestFloatNonIntegerArgument:
     """
     These test that ``TypeError`` is raised when you try to use
diff --git a/numpy/_core/tests/test_numerictypes.py b/numpy/_core/tests/test_numerictypes.py
@@ -347,17 +347,16 @@ def test_assign(self):
 
 
 class TestMultipleFields:
-    def setup_method(self):
-        self.ary = np.array([(1, 2, 3, 4), (5, 6, 7, 8)], dtype='i4,f4,i2,c8')
-
     def _bad_call(self):
-        return self.ary['f0', 'f1']
+        ary = np.array([(1, 2, 3, 4), (5, 6, 7, 8)], dtype='i4,f4,i2,c8')
+        return ary['f0', 'f1']
 
     def test_no_tuple(self):
         assert_raises(IndexError, self._bad_call)
 
     def test_return(self):
-        res = self.ary[['f0', 'f2']].tolist()
+        ary = np.array([(1, 2, 3, 4), (5, 6, 7, 8)], dtype='i4,f4,i2,c8')
+        res = ary[['f0', 'f2']].tolist()
         assert_(res == [(1, 3), (5, 7)])
 
 
diff --git a/numpy/_core/tests/test_records.py b/numpy/_core/tests/test_records.py
@@ -359,26 +359,26 @@ def test_tofile_fromfile(self):
 
 
 class TestRecord:
-    def setup_method(self):
-        self.data = np.rec.fromrecords([(1, 2, 3), (4, 5, 6)],
+    def _create_data(self):
+        return np.rec.fromrecords([(1, 2, 3), (4, 5, 6)],
                             dtype=[("col1", "<i4"),
                                    ("col2", "<i4"),
                                    ("col3", "<i4")])
 
     def test_assignment1(self):
-        a = self.data
+        a = self._create_data()
         assert_equal(a.col1[0], 1)
         a[0].col1 = 0
         assert_equal(a.col1[0], 0)
 
     def test_assignment2(self):
-        a = self.data
+        a = self._create_data()
         assert_equal(a.col1[0], 1)
         a.col1[0] = 0
         assert_equal(a.col1[0], 0)
 
     def test_invalid_assignment(self):
-        a = self.data
+        a = self._create_data()
 
         def assign_invalid_column(x):
             x[0].col5 = 1
@@ -396,14 +396,14 @@ def test_nonwriteable_setfield(self):
 
     def test_out_of_order_fields(self):
         # names in the same order, padding added to descr
-        x = self.data[['col1', 'col2']]
+        x = self._create_data()[['col1', 'col2']]
         assert_equal(x.dtype.names, ('col1', 'col2'))
         assert_equal(x.dtype.descr,
                      [('col1', '<i4'), ('col2', '<i4'), ('', '|V4')])
 
         # names change order to match indexing, as of 1.14 - descr can't
         # represent that
-        y = self.data[['col2', 'col1']]
+        y = self._create_data()[['col2', 'col1']]
         assert_equal(y.dtype.names, ('col2', 'col1'))
         assert_raises(ValueError, lambda: y.dtype.descr)
 
@@ -416,15 +416,15 @@ def test_pickle_1(self):
                                                          protocol=proto)))
 
     def test_pickle_2(self):
-        a = self.data
+        a = self._create_data()
         for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
             assert_equal(a, pickle.loads(pickle.dumps(a, protocol=proto)))
             assert_equal(a[0], pickle.loads(pickle.dumps(a[0],
                                                          protocol=proto)))
 
     def test_pickle_3(self):
         # Issue #7140
-        a = self.data
+        a = self._create_data()
         for proto in range(2, pickle.HIGHEST_PROTOCOL + 1):
             pa = pickle.loads(pickle.dumps(a[0], protocol=proto))
             assert_(pa.flags.c_contiguous)
