logitscale: update and add tests for ticker.LogitLocator

jb-leger · jb-leger · commit 99a4cf1a5da6 · 2019-06-10T12:16:14.000+02:00
diff --git a/lib/matplotlib/tests/test_ticker.py b/lib/matplotlib/tests/test_ticker.py
@@ -239,14 +239,112 @@ def test_set_params(self):
 
 
 class TestLogitLocator:
-    def test_set_params(self):
+    ref_basic_limits = [
+        (5e-2, 1 - 5e-2),
+        (5e-3, 1 - 5e-3),
+        (5e-4, 1 - 5e-4),
+        (5e-5, 1 - 5e-5),
+        (5e-6, 1 - 5e-6),
+        (5e-7, 1 - 5e-7),
+        (5e-8, 1 - 5e-8),
+        (5e-9, 1 - 5e-9),
+        (5e-10, 1 - 5e-10),
+    ]
+
+    ref_basic_major_ticks = [
+        1 / (10 ** np.arange(1, 3)),
+        1 / (10 ** np.arange(1, 4)),
+        1 / (10 ** np.arange(1, 5)),
+        1 / (10 ** np.arange(1, 6)),
+        1 / (10 ** np.arange(1, 7)),
+        1 / (10 ** np.arange(1, 8)),
+        1 / (10 ** np.arange(1, 9)),
+        1 / (10 ** np.arange(1, 10)),
+        1 / (10 ** np.arange(1, 11)),
+    ]
+
+    ref_maxn_limits = [(0.4, 0.6), (5e-2, 2e-1), (1 - 2e-1, 1 - 5e-2)]
+
+    @pytest.mark.parametrize(
+        "lims, expected_first_ticks",
+        zip(ref_basic_limits, ref_basic_major_ticks),
+    )
+    def test_basic_major(self, lims, expected_first_ticks):
         """
-        Create logit locator with default minor=False, and change it to
-        something else. See if change was successful. Should not exception.
+        Create logit locator with huge number of major, and tests ticks.
+        """
+        expected_ticks = np.sort(
+            np.concatenate(
+                (expected_first_ticks, (1 / 2,), 1 - expected_first_ticks)
+            )
+        )
+        loc = mticker.LogitLocator(nbins=100)
+        assert_almost_equal(loc.tick_values(*lims), expected_ticks)
+
+    @pytest.mark.parametrize("lims", ref_maxn_limits)
+    def test_maxn_major(self, lims):
         """
-        loc = mticker.LogitLocator()  # Defaults to false.
-        loc.set_params(minor=True)
-        assert loc.minor
+        When the axis is zoomed, the locator must have the same behavior as
+        MaxNLocator.
+        """
+        loc = mticker.LogitLocator(nbins=100)
+        maxn_loc = mticker.MaxNLocator(nbins=100, steps=[1, 2, 5, 10])
+        for nbins in (4, 8, 16):
+            loc.set_params(nbins=nbins)
+            maxn_loc.set_params(nbins=nbins)
+            ticks = loc.tick_values(*lims)
+            maxn_ticks = maxn_loc.tick_values(*lims)
+            assert ticks.shape == maxn_ticks.shape
+            assert (ticks == maxn_ticks).all()
+
+    @pytest.mark.parametrize("lims", ref_basic_limits + ref_maxn_limits)
+    def test_nbins_major(self, lims):
+        """
+        Assert logit locator for respecting nbins param.
+        """
+
+        basic_needed = int(-np.floor(np.log10(lims[0]))) * 2 + 1
+        loc = mticker.LogitLocator(nbins=100)
+        for nbins in range(basic_needed, 2, -1):
+            loc.set_params(nbins=nbins)
+            assert len(loc.tick_values(*lims)) <= nbins + 2
+
+    @pytest.mark.parametrize(
+        "lims, expected_first_ticks",
+        zip(ref_basic_limits, ref_basic_major_ticks),
+    )
+    def test_minor(self, lims, expected_first_ticks):
+        """
+        In large scale, test the presence of minor,
+        and assert no minor when major are subsampled.
+        """
+
+        expected_ticks = np.sort(
+            np.concatenate(
+                (expected_first_ticks, (1 / 2,), 1 - expected_first_ticks)
+            )
+        )
+
+        basic_needed = len(expected_ticks)
+        loc = mticker.LogitLocator(nbins=100)
+        minor_loc = mticker.LogitLocator(nbins=100, minor=True)
+        for nbins in range(basic_needed, 2, -1):
+            loc.set_params(nbins=nbins)
+            minor_loc.set_params(nbins=nbins)
+            major_ticks = loc.tick_values(*lims)
+            minor_ticks = minor_loc.tick_values(*lims)
+            if len(major_ticks) >= len(expected_ticks):
+                # no subsample, we must have a lot of minors ticks
+                assert (len(major_ticks) - 1) * 5 < len(minor_ticks)
+            else:
+                # subsample
+                assert len(major_ticks) + len(minor_ticks) == len(
+                    expected_ticks
+                )
+                assert_almost_equal(
+                    np.sort(np.concatenate((major_ticks, minor_ticks))),
+                    expected_ticks,
+                )
 
 
 class TestFixedLocator:
