TST: add tests for DivergingNorm

jklymak · jklymak · commit acb0dc75fa70 · 2018-10-06T20:51:32.000-07:00
diff --git a/lib/matplotlib/colors.py b/lib/matplotlib/colors.py
@@ -1036,8 +1036,13 @@ def __call__(self, value, clip=None):
         self.autoscale_None(result)
         vmin, vmax = self._data_points[0], self._data_points[-1]
 
+
         # its possible some of the data points are less than vmin
-        # or vmax.
+        # or vmax.  We could error out if some stop points are
+        # overrun, but this lets things keep going...
+
+        if not np.all(np.diff(self._data_points) >= 0):
+             raise ValueError("data points must increase monotonically")
         ind = np.where((self._data_points >= vmin) &
                        (self._data_points <= vmax))[0]
         result = np.ma.masked_array(np.interp(result,
@@ -1081,6 +1086,8 @@ def autoscale_None(self, A):
 
         self._data_points[0] = vmin
         self._data_points[-1] = vmax
+        self.vmin = vmin
+        self.vmax = vmax
 
 
 class DivergingNorm(PiecewiseLinearNorm):
diff --git a/lib/matplotlib/tests/baseline_images/test_colors/test_offset_norm.png b/lib/matplotlib/tests/baseline_images/test_colors/test_offset_norm.png
diff --git a/lib/matplotlib/tests/test_colors.py b/lib/matplotlib/tests/test_colors.py
@@ -3,7 +3,7 @@
 import numpy as np
 import pytest
 
-from numpy.testing import assert_array_equal, assert_array_almost_equal
+from numpy.testing import (assert_array_equal, assert_array_almost_equal)
 
 from matplotlib import cycler
 import matplotlib
@@ -220,187 +220,101 @@ def test_Normalize():
     assert 0 < norm(1 + 50 * eps) < 1
 
 
-class BaseNormMixin(object):
-    def test_call(self):
-        normed_vals = self.norm(self.vals)
-        np.assert_array_almost_equal(normed_vals, self.expected)
+def test_DivergingNorm_autoscale():
+    norm = mcolors.DivergingNorm()
+    norm.autoscale([10, 20, 30, 40])
+    assert norm.vmin == 10.
+    assert norm.vmax == 40.
 
-    def test_inverse(self):
-        if self.test_inverse:
-            _inverse_tester(self.norm, self.vals)
-        else:
-            pass
-
-    def test_scalar(self):
-        _scalar_tester(self.norm, self.vals)
-
-    def test_mask(self):
-        _mask_tester(self.norm, self.vals)
-
-    def test_autoscale(self):
-        norm = self.normclass()
-        norm.autoscale([10, 20, 30, 40])
-        np.assert_equal(norm.vmin, 10.)
-        np.assert_equal(norm.vmax, 40.)
-
-    def test_autoscale_None_vmin(self):
-        norm = self.normclass(vmin=0, vmax=None)
-        norm.autoscale_None([1, 2, 3, 4, 5])
-        np.assert_equal(norm.vmin, 0.)
-        np.assert_equal(norm.vmax, 5.)
-
-    def test_autoscale_None_vmax(self):
-        norm = self.normclass(vmin=None, vmax=10)
-        norm.autoscale_None([1, 2, 3, 4, 5])
-        np.assert_equal(norm.vmin, 1.)
-        np.assert_equal(norm.vmax, 10.)
-
-    def test_scale(self):
-        norm = self.normclass()
-        np.assert_false(norm.scaled())
-
-        norm([1, 2, 3, 4])
-        np.assert_true(norm.scaled())
-
-    def test_process_value_scalar(self):
-        res, is_scalar = mcolors.Normalize.process_value(5)
-        np.assert_true(is_scalar)
-        assert_array_equal(res, np.array([5.]))
-
-    def test_process_value_list(self):
-        res, is_scalar = mcolors.Normalize.process_value([5, 10])
-        np.assert_false(is_scalar)
-        np.assert_array_equal(res, np.array([5., 10.]))
-
-    def test_process_value_tuple(self):
-        res, is_scalar = mcolors.Normalize.process_value((5, 10))
-        np.assert_false(is_scalar)
-        np.assert_array_equal(res, np.array([5., 10.]))
-
-    def test_process_value_array(self):
-        res, is_scalar = mcolors.Normalize.process_value(np.array([5, 10]))
-        np.assert_false(is_scalar)
-        np.assert_array_equal(res, np.array([5., 10.]))
-
-
-class BaseDivergingNorm(BaseNormMixin):
-    normclass = mcolors.DivergingNorm
-    test_inverse = False
-
-
-class test_DivergingNorm_Even(BaseDivergingNorm):
-    def setup(self):
-        self.norm = self.normclass(vmin=-1, vcenter=0, vmax=4)
-        self.vals = np.array([-1.0, -0.5, 0.0, 1.0, 2.0, 3.0, 4.0])
-        self.expected = np.array([0.0, 0.25, 0.5, 0.625, 0.75, 0.875, 1.0])
-
-
-class test_DivergingNorm_Odd(BaseDivergingNorm):
-    def setup(self):
-        self.normclass = mcolors.DivergingNorm
-        self.norm = self.normclass(vmin=-2, vcenter=0, vmax=5)
-        self.vals = np.array([-2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
-        self.expected = np.array([0.0, 0.25, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
-
-
-class test_DivergingNorm_AllNegative(BaseDivergingNorm):
-    def setup(self):
-        self.normclass = mcolors.DivergingNorm
-        self.norm = self.normclass(vmin=-10, vcenter=-8, vmax=-2)
-        self.vals = np.array([-10., -9., -8., -6., -4., -2.])
-        self.expected = np.array([0.0, 0.25, 0.5, 0.666667, 0.833333, 1.0])
-
-
-class test_DivergingNorm_AllPositive(BaseDivergingNorm):
-    def setup(self):
-        self.normclass = mcolors.DivergingNorm
-        self.norm = self.normclass(vmin=0, vcenter=3, vmax=9)
-        self.vals = np.array([0., 1.5, 3., 4.5, 6.0, 7.5, 9.])
-        self.expected = np.array([0.0, 0.25, 0.5, 0.625, 0.75, 0.875, 1.0])
-
-
-class test_DivergingNorm_NoVs(BaseDivergingNorm):
-    def setup(self):
-        self.normclass = mcolors.DivergingNorm
-        self.norm = self.normclass(vmin=None, vcenter=None, vmax=None)
-        self.vals = np.array([-2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0])
-        self.expected = np.array([0., 0.16666667, 0.33333333,
-                                  0.5, 0.66666667, 0.83333333, 1.0])
-        self.expected_vmin = -2
-        self.expected_vcenter = 1
-        self.expected_vmax = 4
-
-    def test_vmin(self):
-        np.assert_true(self.norm.vmin is None)
-        self.norm(self.vals)
-        np.assert_equal(self.norm.vmin, self.expected_vmin)
-
-    def test_vcenter(self):
-        np.assert_true(self.norm.vcenter is None)
-        self.norm(self.vals)
-        np.assert_equal(self.norm.vcenter, self.expected_vcenter)
-
-    def test_vmax(self):
-        np.assert_true(self.norm.vmax is None)
-        self.norm(self.vals)
-        np.assert_equal(self.norm.vmax, self.expected_vmax)
-
-
-class test_DivergingNorm_VminEqualsVcenter(BaseDivergingNorm):
-    def setup(self):
-        self.normclass = mcolors.DivergingNorm
-        self.norm = self.normclass(vmin=-2, vcenter=-2, vmax=2)
-        self.vals = np.array([-2.0, -1.0, 0.0, 1.0, 2.0])
-        self.expected = np.array([0.5, 0.625, 0.75, 0.875, 1.0])
-
-
-class test_DivergingNorm_VmaxEqualsVcenter(BaseDivergingNorm):
-    def setup(self):
-        self.normclass = mcolors.DivergingNorm
-        self.norm = self.normclass(vmin=-2, vcenter=2, vmax=2)
-        self.vals = np.array([-2.0, -1.0, 0.0, 1.0, 2.0])
-        self.expected = np.array([0.0, 0.125, 0.25, 0.375, 0.5])
-
-
-class test_DivergingNorm_VsAllEqual(BaseDivergingNorm):
-    def setup(self):
-        self.v = 10
-        self.normclass = mcolors.DivergingNorm
-        self.norm = self.normclass(vmin=self.v, vcenter=self.v, vmax=self.v)
-        self.vals = np.array([-2.0, -1.0, 0.0, 1.0, 2.0])
-        self.expected = np.array([0.0, 0.0, 0.0, 0.0, 0.0])
-        self.expected_inv = self.expected + self.v
-
-    def test_inverse(self):
-        assert_array_almost_equal(
-            self.norm.inverse(self.norm(self.vals)),
-            self.expected_inv
-        )
-
-
-class test_DivergingNorm_Errors(object):
-    def setup(self):
-        self.vals = np.arange(50)
-
-    def test_VminGTVcenter(self):
-        with pytest.raises(ValueError):
-            norm = mcolors.DivergingNorm(vmin=10, vcenter=0, vmax=20)
-            norm(self.vals)
-
-    def test_VminGTVmax(self):
-        with pytest.raises(ValueError):
-            norm = mcolors.DivergingNorm(vmin=10, vcenter=0, vmax=5)
-            norm(self.vals)
-
-    def test_VcenterGTVmax(self):
-        with pytest.raises(ValueError):
-            norm = mcolors.DivergingNorm(vmin=10, vcenter=25, vmax=20)
-            norm(self.vals)
-
-    def test_premature_scaling(self):
-        with pytest.raises(ValueError):
-            norm = mcolors.DivergingNorm()
-            norm.inverse(np.array([0.1, 0.5, 0.9]))
+
+def test_DivergingNorm_autoscale_None_vmin():
+    norm = mcolors.DivergingNorm(vmin=0, vmax=None)
+    norm.autoscale_None([1, 2, 3, 4, 5])
+    assert norm(5) == 1
+    assert norm.vmax == 5
+
+
+def test_DivergingNorm_autoscale_None_vmax():
+    norm = mcolors.DivergingNorm(vmin=None, vmax=10)
+    norm.autoscale_None([1, 2, 3, 4, 5])
+    assert norm(1) == 0
+    assert norm.vmin == 1
+
+
+def test_DivergingNorm_scale():
+    norm = mcolors.DivergingNorm()
+    assert norm.scaled() is False
+    norm([1, 2, 3, 4])
+    assert norm.scaled() is True
+
+
+def test_DivergingNorm_scaleout_center():
+    norm = mcolors.DivergingNorm(vcenter=0)
+    # if the center is defined outside the data limits, should raise an err.
+    with pytest.raises(ValueError):
+        norm([1, 2, 3, 5])
+
+
+def test_DivergingNorm_Even():
+    norm = mcolors.DivergingNorm(vmin=-1, vcenter=0, vmax=4)
+    vals = np.array([-1.0, -0.5, 0.0, 1.0, 2.0, 3.0, 4.0])
+    expected = np.array([0.0, 0.25, 0.5, 0.625, 0.75, 0.875, 1.0])
+    assert_array_equal(norm(vals), expected)
+
+
+def test_DivergingNorm_Odd():
+    norm = mcolors.DivergingNorm(vmin=-2, vcenter=0, vmax=5)
+    vals = np.array([-2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
+    expected = np.array([0.0, 0.25, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0])
+    assert_array_equal(norm(vals), expected)
+
+
+def test_DivergingNorm_VminEqualsVcenter():
+    norm = mcolors.DivergingNorm(vmin=-2, vcenter=-2, vmax=2)
+    vals = np.array([-2.0, -1.0, 0.0, 1.0, 2.0])
+    expected = np.array([0.5, 0.625, 0.75, 0.875, 1.0])
+    assert_array_equal(norm(vals), expected)
+
+
+def test_DivergingNorm_VmaxEqualsVcenter():
+    norm = mcolors.DivergingNorm(vmin=-2, vcenter=2, vmax=2)
+    vals = np.array([-2.0, -1.0, 0.0, 1.0, 1.999, 2.0])
+    expected = np.array([0.0, 0.125, 0.25, 0.375, 0.499875, 1.0])
+    assert_array_equal(norm(vals), expected)
+
+
+def test_DivergingNorm_VsAllEqual():
+    v = 10
+    mcolors.DivergingNorm = mcolors.DivergingNorm
+    norm = mcolors.DivergingNorm(vmin=v, vcenter=v, vmax=v)
+    vals = np.array([-2.0, -1.0, 0.0, 1.0, 2.0])
+    expected = np.array([0.0, 0.0, 0.0, 0.0, 0.0])
+    assert_array_equal(norm(vals), expected)
+
+
+def test_DivergingNorm_VminGTVcenter():
+    vals = np.arange(50)
+    with pytest.raises(ValueError):
+        norm = mcolors.DivergingNorm(vmin=10, vcenter=0, vmax=20)
+        norm(vals)
+
+
+def test_DivergingNorm_DivergingNorm_VminGTVmax():
+    with pytest.raises(ValueError):
+        norm = mcolors.DivergingNorm(vmin=10, vcenter=0, vmax=5)
+
+
+def test_DivergingNorm_VcenterGTVmax():
+    vals = np.arange(50)
+    with pytest.raises(ValueError):
+        norm = mcolors.DivergingNorm(vmin=10, vcenter=25, vmax=20)
+        norm(vals)
+
+
+def test_DivergingNorm_premature_scaling():
+    with pytest.raises(ValueError):
+        norm = mcolors.DivergingNorm()
+        norm.inverse(np.array([0.1, 0.5, 0.9]))
 
 
 @image_comparison(baseline_images=['test_offset_norm'], extensions=['png'],
