Make tests a bit clearer using fixture

Author: reidy-p

pandas/tests/indexes/test_range.py

@@ -580,7 +580,9 @@ def test_union_noncomparable(self):
         expected = Index(np.concatenate((other, self.index)))
         tm.assert_index_equal(result, expected)
 
-    def test_union(self):
+    @pytest.fixture
+    def union_inputs(self):
+        """Inputs for RangeIndex.union tests"""
         RI = RangeIndex
         I64 = Int64Index
 
@@ -607,67 +609,73 @@ def test_union(self):
                   (RI(0, 10, 1), I64([])),
                   (RI(0), I64([1, 5, 6]))]
 
-        expected_sorted = [RI(0, 10, 1),
-                           RI(0, 20, 1),
-                           RI(0, 20, 1),
-                           RI(0, -10, -1),
-                           RI(-19, 1, 1),
-                           RI(0, 10, 1),
-                           RI(0, 12, 1),
-                           RI(-2, 24, 2),
-                           RI(-19, 1, 1),
-                           RI(0, 100, 5),
-                           RI(-95, 10, 5),
-                           RI(-11, 2, 1),
-                           RI(0),
-                           RI(0, -10, -2),
-                           RI(0, 102, 2),
-                           RI(-100, 4, 2),
-                           RI(-99, 1, 1),
-                           RI(0, 6, 5),
-                           RI(-5, 10, 5),
-                           I64([0, 1, 2, 4]),
-                           RI(0, 10, 1),
-                           I64([1, 5, 6])]
-
-        for ((idx1, idx2), expected) in zip(inputs, expected_sorted):
+        return inputs
+
+    def test_union_sorted(self, union_inputs):
+        RI = RangeIndex
+        I64 = Int64Index
+
+        expected = [RI(0, 10, 1),
+                    RI(0, 20, 1),
+                    RI(0, 20, 1),
+                    RI(0, -10, -1),
+                    RI(-19, 1, 1),
+                    RI(0, 10, 1),
+                    RI(0, 12, 1),
+                    RI(-2, 24, 2),
+                    RI(-19, 1, 1),
+                    RI(0, 100, 5),
+                    RI(-95, 10, 5),
+                    RI(-11, 2, 1),
+                    RI(0),
+                    RI(0, -10, -2),
+                    RI(0, 102, 2),
+                    RI(-100, 4, 2),
+                    RI(-99, 1, 1),
+                    RI(0, 6, 5),
+                    RI(-5, 10, 5),
+                    I64([0, 1, 2, 4]),
+                    RI(0, 10, 1),
+                    I64([1, 5, 6])]
+
+        for ((idx1, idx2), expected_sorted) in zip(union_inputs, expected):
             res1 = idx1.union(idx2)
+            tm.assert_index_equal(res1, expected_sorted, exact=True)
             res2 = idx2.union(idx1)
             res3 = idx1._int64index.union(idx2)
-            tm.assert_index_equal(res1, expected, exact=True)
-            tm.assert_index_equal(res2, expected, exact=True)
-            tm.assert_index_equal(res3, expected)
-
-        expected_notsorted = [RI(0, 10, 1),
-                              I64(range(20)),
-                              I64(range(20)),
-                              RI(0, -10, -1),
-                              I64(range(0, -20, -1)),
-                              I64(list(range(0, 10, 2)) +
-                                  list(range(1, 10, 2))),
-                              I64(list(range(0, 11, 2)) +
-                                  list(range(1, 12, 2))),
-                              I64(list(range(0, 21, 4)) +
-                                  list(range(-2, 24, 4))),
-                              I64(list(range(0, -20, -2)) +
-                                  list(range(-1, -21, -2))),
-                              I64(range(0, 100, 5)),
-                              I64(list(range(0, -100, -5)) + [5]),
-                              I64(list(range(0, -11, -1)) + [1, -11]),
-                              RI(0),
-                              RI(0, -10, -2),
-                              I64(range(0, 102, 2)),
-                              I64(list(range(0, -100, -2)) + [-100, 2]),
-                              I64(list(range(0, -100, -1))),
-                              I64([0, 5]),
-                              I64([0, 5, -5]),
-                              I64([0, 1, 2, 4]),
-                              RI(0, 10, 1),
-                              I64([1, 5, 6])]
-
-        for ((idx1, idx2), expected) in zip(inputs, expected_notsorted):
+            tm.assert_index_equal(res2, expected_sorted, exact=True)
+            tm.assert_index_equal(res3, expected_sorted)
+
+    def test_union_notsorted(self, union_inputs):
+        RI = RangeIndex
+        I64 = Int64Index
+
+        expected = [RI(0, 10, 1),
+                    I64(range(20)),
+                    I64(range(20)),
+                    RI(0, -10, -1),
+                    I64(range(0, -20, -1)),
+                    I64(list(range(0, 10, 2)) + list(range(1, 10, 2))),
+                    I64(list(range(0, 11, 2)) + list(range(1, 12, 2))),
+                    I64(list(range(0, 21, 4)) + list(range(-2, 24, 4))),
+                    I64(list(range(0, -20, -2)) + list(range(-1, -21, -2))),
+                    I64(range(0, 100, 5)),
+                    I64(list(range(0, -100, -5)) + [5]),
+                    I64(list(range(0, -11, -1)) + [1, -11]),
+                    RI(0),
+                    RI(0, -10, -2),
+                    I64(range(0, 102, 2)),
+                    I64(list(range(0, -100, -2)) + [-100, 2]),
+                    I64(list(range(0, -100, -1))),
+                    I64([0, 5]),
+                    I64([0, 5, -5]),
+                    I64([0, 1, 2, 4]),
+                    RI(0, 10, 1),
+                    I64([1, 5, 6])]
+
+        for ((idx1, idx2), expected_notsorted) in zip(union_inputs, expected):
             res1 = idx1.union(idx2, sort=False)
-            tm.assert_index_equal(res1, expected, exact=True)
+            tm.assert_index_equal(res1, expected_notsorted, exact=True)
 
     def test_nbytes(self):