Merge pull request #2932 from unnonouno/variable-deprecation

Check DeprecationWarning in Variable

chainer/testing/__init__.py

@@ -8,6 +8,7 @@
 from chainer.testing import unary_math_function_test  # NOQA
 
 from chainer.testing.array import assert_allclose  # NOQA
+from chainer.testing.helper import assert_warns  # NOQA
 from chainer.testing.helper import with_requires  # NOQA
 from chainer.testing.parameterized import parameterize  # NOQA
 from chainer.testing.parameterized import product  # NOQA

chainer/testing/helper.py

@@ -1,5 +1,7 @@
+import contextlib
 import pkg_resources
 import unittest
+import warnings
 
 
 def with_requires(*requirements):
@@ -29,3 +31,20 @@ def with_requires(*requirements):
 
     msg = 'requires: {}'.format(','.join(requirements))
     return unittest.skipIf(skip, msg)
+
+
+@contextlib.contextmanager
+def assert_warns(expected):
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter('always')
+        yield
+
+    if any(isinstance(m.message, expected) for m in w):
+        return
+
+    try:
+        exc_name = expected.__name__
+    except AttributeError:
+        exc_name = str(expected)
+
+    raise AssertionError('%s not triggerred' % exc_name)

tests/chainer_tests/test_link.py

@@ -312,7 +312,8 @@ def test_cleargrads(self):
     def test_zerograds(self):
         gx_expect = numpy.zeros_like(self.link.x.data)
         gy_expect = numpy.zeros_like(self.link.y.data)
-        self.link.zerograds()
+        with testing.assert_warns(DeprecationWarning):
+            self.link.zerograds()
         numpy.testing.assert_array_equal(self.link.x.grad, gx_expect)
         numpy.testing.assert_array_equal(self.link.y.grad, gy_expect)
         self.link.u.initialize((2, 3))
@@ -656,7 +657,8 @@ def test_copyparams(self):
 
     def test_zerograds(self):
         self.set_count_parameters()
-        self.c2.zerograds()
+        with testing.assert_warns(DeprecationWarning):
+            self.c2.zerograds()
         numpy.testing.assert_array_equal(self.l1.x.grad, numpy.zeros((2, 3)))
         numpy.testing.assert_array_equal(self.l2.x.grad, numpy.zeros(2))
         self.assertEqual(self.l1.x.count_zerograd, 1)
@@ -942,7 +944,8 @@ def test_copyparams(self):
         numpy.testing.assert_array_equal(self.l3.x.data, l3.x.data)
 
     def test_zerograds(self):
-        self.c2.zerograds()
+        with testing.assert_warns(DeprecationWarning):
+            self.c2.zerograds()
         numpy.testing.assert_array_equal(self.l1.x.grad, numpy.zeros((2, 3)))
         numpy.testing.assert_array_equal(self.l2.x.grad, numpy.zeros(2))
         numpy.testing.assert_array_equal(self.l3.x.grad, numpy.zeros(3))

tests/chainer_tests/test_variable.py

@@ -417,7 +417,8 @@ def check_zerograd(self, a_data, fill=False):
             a.grad_var = chainer.Variable(xp.full_like(a_data, np.nan))
             a.grad_var.creator_node = chainer.FunctionNode()
 
-        a.zerograd()
+        with testing.assert_warns(DeprecationWarning):
+            a.zerograd()
         self.assertIsNot(a.grad, None)
         if fill:
             self.assertIsNone(a.grad_var.creator_node)
@@ -435,7 +436,8 @@ def test_zerograds_multi_gpu(self):
         cupy = cuda.cupy
         with cuda.get_device_from_id(1):
             a = chainer.Variable(cupy.empty(3, dtype=np.float32))
-        a.zerograd()
+        with testing.assert_warns(DeprecationWarning):
+            a.zerograd()
         self.assertIsNot(a.grad, None)
         self.assertEqual(int(a.grad.device), 1)
         with cuda.get_device_from_id(1):
@@ -448,7 +450,8 @@ def test_zerograds_fill_multi_gpu(self):
         with cuda.get_device_from_id(1):
             a = chainer.Variable(cupy.empty(3, dtype=np.float32))
             a.grad = cupy.empty_like(a.data)
-        a.zerograd()
+        with testing.assert_warns(DeprecationWarning):
+            a.zerograd()
         self.assertEqual(int(a.grad.device), 1)
         with cuda.get_device_from_id(1):
             g_expect = cupy.zeros_like(a.data)
@@ -788,14 +791,16 @@ def check_zerograd(self, x, xp):
 
     def test_zerograd(self):
         x = chainer.Parameter()
-        x.zerograd()
+        with testing.assert_warns(DeprecationWarning):
+            x.zerograd()
         x.initialize((3, 2))
         self.check_zerograd(x, np)
 
     @attr.gpu
     def test_zerograd_to_gpu(self):
         x = chainer.Parameter()
-        x.zerograd()
+        with testing.assert_warns(DeprecationWarning):
+            x.zerograd()
         x.to_gpu()
         x.initialize((3, 2))
         self.check_zerograd(x, cuda.cupy)
@@ -804,13 +809,15 @@ def test_zerograd_to_gpu(self):
     def test_to_gpu_zerograd(self):
         x = chainer.Parameter()
         x.to_gpu()
-        x.zerograd()
+        with testing.assert_warns(DeprecationWarning):
+            x.zerograd()
         x.initialize((3, 2))
         self.check_zerograd(x, cuda.cupy)
 
     def test_zerograd_dtype(self):
         x = chainer.Parameter(initializers.Zero(dtype=np.float16))
-        x.zerograd()
+        with testing.assert_warns(DeprecationWarning):
+            x.zerograd()
         x.initialize((3, 2))
         self.assertEqual(x.grad.dtype, x.data.dtype)
 
@@ -944,7 +951,8 @@ def check_debug_print(self, v, mean, std):
         self.assertIn('grad: None', result)
 
         # zero grad
-        v.zerograd()
+        with testing.assert_warns(DeprecationWarning):
+            v.zerograd()
         result = v.debug_print()
         self.assertIn('grad: 0', result)