Refactored tests to use AssertQuantityEqual and AssertQuantityAlmostEqual

Also created a contextmanager to capture log outputs.

10 files changed, 222 insertions, 250 deletions

diff --git a/pint/testsuite/__init__.py b/pint/testsuite/__init__.py
index 2254653..e26296f 100644
--- a/pint/testsuite/__init__.py
+++ b/pint/testsuite/__init__.py
@@ -4,6 +4,7 @@ from __future__ import division, unicode_literals, print_function, absolute_impo
 
 import os
 import logging
+from contextlib import contextmanager
 
 from pint.compat import ndarray, unittest, np
 
@@ -11,39 +12,64 @@ from pint import logger, UnitRegistry
 from pint.quantity import _Quantity
 from logging.handlers import BufferingHandler
 
-h = logging.StreamHandler()
-f = logging.Formatter("%(levelname)s %(asctime)s %(funcName)s %(lineno)d %(message)s")
-h.setLevel(logging.DEBUG)
-h.setFormatter(f)
-logger.addHandler(h)
-logger.setLevel(logging.DEBUG)
+#h = logging.StreamHandler()
+#f = logging.Formatter("%(levelname)s %(asctime)s %(funcName)s %(lineno)d %(message)s")
+#h.setLevel(logging.DEBUG)
+#h.setFormatter(f)
+#logger.addHandler(h)
+#logger.setLevel(logging.DEBUG)
 
 
 class TestHandler(BufferingHandler):
-    def __init__(self):
+
+    def __init__(self, only_warnings=False):
         # BufferingHandler takes a "capacity" argument
         # so as to know when to flush. As we're overriding
         # shouldFlush anyway, we can set a capacity of zero.
         # You can call flush() manually to clear out the
         # buffer.
+        self.only_warnings = only_warnings
         BufferingHandler.__init__(self, 0)
 
     def shouldFlush(self):
         return False
 
     def emit(self, record):
+        if self.only_warnings and record.level != logging.WARNING:
+            return
         self.buffer.append(record.__dict__)
 
 
-class TestCase(unittest.TestCase):
+class QuantityTestCase(unittest.TestCase):
 
     FORCE_NDARRAY = False
 
+    CHECK_NO_WARNING = False
+
     @classmethod
     def setUpClass(cls):
         cls.ureg = UnitRegistry(force_ndarray=cls.FORCE_NDARRAY)
         cls.Q_ = cls.ureg.Quantity
 
+    @contextmanager
+    def capture_log(self, level=logging.DEBUG):
+        th = TestHandler()
+        th.setLevel(level)
+        logger.addHandler(th)
+        yield th.buffer
+
+    def setUp(self):
+        self._test_handler = None
+        if self.CHECK_NO_WARNING:
+            self._test_handler = th = TestHandler()
+            th.setLevel(logging.WARNING)
+            logger.addHandler(th)
+
+    def tearDown(self):
+        if self._test_handler is not None:
+            l = len(self._test_handler.buffer)
+            self.assertEqual(l, 0, msg='%d warnings raised.')
+
     def _get_comparable_magnitudes(self, first, second, msg):
         if isinstance(first, _Quantity) and isinstance(second, _Quantity):
             second = second.to(first)
@@ -62,25 +88,6 @@ class TestCase(unittest.TestCase):
 
         return m1, m2
 
-    def assertSequenceEqual(self, seq1, seq2, msg=None, seq_type=None):
-        if isinstance(seq1, _Quantity):
-            if isinstance(seq2, _Quantity):
-                seq2 = seq2.to(seq1).magnitude
-                seq1 = seq1.magnitude
-            else:
-                seq1 = seq1.to('').magnitude
-        if isinstance(seq2, _Quantity):
-            if isinstance(seq1, _Quantity):
-                seq1 = seq1.to(seq2).magnitude
-                seq2 = seq2.magnitude
-            else:
-                seq2 = seq2.to('').magnitude
-        if isinstance(seq1, ndarray):
-            seq1 = seq1.tolist()
-        if isinstance(seq2, ndarray):
-            seq2 = seq2.tolist()
-        unittest.TestCase.assertSequenceEqual(self, seq1, seq2, msg, seq_type)
-
     def assertQuantityEqual(self, first, second, msg=None):
         if msg is None:
             msg = 'Comparing %r and %r. ' % (first, second)
@@ -90,55 +97,18 @@ class TestCase(unittest.TestCase):
         if isinstance(m1, ndarray) or isinstance(m2, ndarray):
             np.testing.assert_array_equal(m1, m2, err_msg=msg)
         else:
-            unittest.TestCase.assertEqual(self, m1, m2, msg, )
+            unittest.TestCase.assertEqual(self, m1, m2, msg)
 
-    def assertQuantityAlmostEqual(self, first, second, places=None, msg=None, delta=None):
+    def assertQuantityAlmostEqual(self, first, second, rtol=1e-07, atol=0, msg=None):
         if msg is None:
             msg = 'Comparing %r and %r. ' % (first, second)
 
         m1, m2 = self._get_comparable_magnitudes(first, second, msg)
 
         if isinstance(m1, ndarray) or isinstance(m2, ndarray):
-            if delta is not None:
-                rtol, atol = 0, delta
-            else:
-                places = places or 7
-                rtol, atol = 10 ** (-places), 0
             np.testing.assert_allclose(m1, m2, rtol=rtol, atol=atol, err_msg=msg)
         else:
-            unittest.TestCase.assertAlmostEqual(self, m1, m2, places, msg, delta)
-
-    def assertAlmostEqual(self, first, second, places=None, msg=None, delta=None):
-        if isinstance(first, _Quantity) and isinstance(second, _Quantity):
-            second = second.to(first)
-            unittest.TestCase.assertAlmostEqual(self, first.magnitude, second.magnitude, places, msg, delta)
-            self.assertEqual(first.units, second.units)
-        elif isinstance(first, _Quantity):
-            self.assertTrue(first.dimensionless)
-            first = first.to('')
-            unittest.TestCase.assertAlmostEqual(self, first.magnitude, second, places, msg, delta)
-        elif isinstance(second, _Quantity):
-            self.assertTrue(second.dimensionless)
-            second = second.to('')
-            unittest.TestCase.assertAlmostEqual(self, first, second.magnitude, places, msg, delta)
-        else:
-            unittest.TestCase.assertAlmostEqual(self, first, second, places, msg, delta)
-
-    def assertAlmostEqualRelError(self, first, second, rel, msg=None):
-        if isinstance(first, _Quantity) and isinstance(second, _Quantity):
-            second = second.to(first)
-            val = abs((second - first) / (second + first))
-        elif isinstance(first, _Quantity):
-            self.assertTrue(first.dimensionless)
-            first = first.to('')
-            val = abs((second - first) / (second + first))
-        elif isinstance(second, _Quantity):
-            self.assertTrue(second.dimensionless)
-            second = second.to('')
-            val = abs((second - first) / (second + first))
-        else:
-            val = abs((second - first) / (second + first))
-        self.assertLess(val, rel, msg=msg)
+            self.assertLessEqual(abs(m1 - m2), atol + rtol * abs(m2))
 
 
 def testsuite():
diff --git a/pint/testsuite/helpers.py b/pint/testsuite/helpers.py
index b75acd8..f11614f 100644
--- a/pint/testsuite/helpers.py
+++ b/pint/testsuite/helpers.py
@@ -4,18 +4,23 @@ from __future__ import division, unicode_literals, print_function, absolute_impo
 
 from pint.compat import unittest, HAS_NUMPY, HAS_UNCERTAINTIES, NUMPY_VER
 
+
 def requires_numpy18():
     return unittest.skipUnless(NUMPY_VER >= '1.8', 'Requires NumPy >= 1.8')
 
+
 def requires_numpy():
     return unittest.skipUnless(HAS_NUMPY, 'Requires NumPy')
 
+
 def requires_not_numpy():
     return unittest.skipIf(HAS_NUMPY, 'Requires NumPy is not installed.')
 
+
 def requires_uncertainties():
     return unittest.skipUnless(HAS_UNCERTAINTIES, 'Requires Uncertainties')
 
+
 def requires_not_uncertainties():
     return unittest.skipIf(HAS_UNCERTAINTIES, 'Requires Uncertainties is not installed.')
 
diff --git a/pint/testsuite/test_contexts.py b/pint/testsuite/test_contexts.py
index 41fa740..f56bf97 100644
--- a/pint/testsuite/test_contexts.py
+++ b/pint/testsuite/test_contexts.py
@@ -8,10 +8,8 @@ from collections import defaultdict
 from pint import UnitRegistry
 from pint.context import Context, _freeze
 from pint.unit import UnitsContainer
-from pint.testsuite import TestCase, TestHandler
-from pint.compat import unittest
+from pint.testsuite import QuantityTestCase
 
-from pint import logger
 
 def add_ctxs(ureg):
     a, b = UnitsContainer({'[length]': 1}), UnitsContainer({'[time]': -1})
@@ -81,7 +79,7 @@ def add_sharedargdef_ctxs(ureg):
     ureg.add_context(d)
 
 
-class TestContexts(unittest.TestCase):
+class TestContexts(QuantityTestCase):
 
     def test_freeze(self):
         self.assertEqual(_freeze('meter'), frozenset([('meter', 1)]))
@@ -571,25 +569,24 @@ class TestContexts(unittest.TestCase):
 
         ureg = UnitRegistry()
 
-        th = TestHandler()
-        logger.addHandler(th)
+        with self.capture_log() as buffer:
+            print(buffer)
+            add_ctxs(ureg)
 
-        add_ctxs(ureg)
-
-        d = Context('ab')
-        ureg.add_context(d)
+            d = Context('ab')
+            ureg.add_context(d)
 
-        self.assertEqual(len(th.buffer), 1)
-        self.assertIn("ab", str(th.buffer[-1]['message']))
+            self.assertEqual(len(buffer), 1)
+            self.assertIn("ab", str(buffer[-1]))
 
-        d = Context('ab1', aliases=('ab',))
-        ureg.add_context(d)
+            d = Context('ab1', aliases=('ab',))
+            ureg.add_context(d)
 
-        self.assertEqual(len(th.buffer), 2)
-        self.assertIn("ab", str(th.buffer[-1]['message']))
+            self.assertEqual(len(buffer), 2)
+            self.assertIn("ab", str(buffer[-1]))
 
 
-class TestDefinedContexts(TestCase):
+class TestDefinedContexts(QuantityTestCase):
 
     FORCE_NDARRAY = False
 
@@ -622,8 +619,8 @@ class TestDefinedContexts(TestCase):
                     self.assertTrue(p)
                     msg = '{0} <-> {1}'.format(a, b)
                     # assertAlmostEqualRelError converts second to first
-                    self.assertAlmostEqualRelError(b, a, rel=.01, msg=msg)
+                    self.assertQuantityAlmostEqual(b, a, rtol=0.01, msg=msg)
 
 
         for a, b in itertools.product(eq, eq):
-            self.assertAlmostEqualRelError(a.to(b.units, 'sp'), b, rel=.01, msg=msg)
+            self.assertQuantityAlmostEqual(a.to(b.units, 'sp'), b, rtol=0.01)
diff --git a/pint/testsuite/test_issues.py b/pint/testsuite/test_issues.py
index a08f276..e659a70 100644
--- a/pint/testsuite/test_issues.py
+++ b/pint/testsuite/test_issues.py
@@ -7,10 +7,10 @@ from pint.unit import UnitsContainer
 from pint.util import ParserHelper
 
 from pint.compat import np, unittest
-from pint.testsuite import TestCase, helpers
+from pint.testsuite import QuantityTestCase, helpers
 
 
-class TestIssues(TestCase):
+class TestIssues(QuantityTestCase):
 
     FORCE_NDARRAY = False
 
@@ -122,7 +122,7 @@ class TestIssues(TestCase):
         boltmk = 1.3806488e-23*ureg.J/ureg.K
         vb = 2. * boltmk * T / m
 
-        self.assertAlmostEqual(va.to_base_units(), vb.to_base_units())
+        self.assertQuantityAlmostEqual(va.to_base_units(), vb.to_base_units())
 
     def test_issue86(self):
         def parts(q):
@@ -170,16 +170,16 @@ class TestIssues(TestCase):
         v1 = 2 * ureg.k * T1 / m
         v2 = 2 * ureg.k * T2 / m
 
-        self.assertAlmostEqual(v1, v2)
-        self.assertAlmostEqual(v1, v2.to_base_units())
-        self.assertAlmostEqual(v1.to_base_units(), v2)
-        self.assertAlmostEqual(v1.to_base_units(), v2.to_base_units())
+        self.assertQuantityAlmostEqual(v1, v2)
+        self.assertQuantityAlmostEqual(v1, v2.to_base_units())
+        self.assertQuantityAlmostEqual(v1.to_base_units(), v2)
+        self.assertQuantityAlmostEqual(v1.to_base_units(), v2.to_base_units())
 
     def test_issue86c(self):
         ureg = self.ureg
         T = ureg.degC
         T = 100. * T
-        self.assertAlmostEqual(ureg.k*2*T, ureg.k*(2*T))
+        self.assertQuantityAlmostEqual(ureg.k*2*T, ureg.k*(2*T))
 
     def test_issue93(self):
         ureg = UnitRegistry()
@@ -193,8 +193,8 @@ class TestIssues(TestCase):
         z += y
         self.assertIsInstance(z.magnitude, float)
 
-        self.assertAlmostEqual(x + y, 5.1 * ureg.meter)
-        self.assertAlmostEqual(z, 5.1 * ureg.meter)
+        self.assertQuantityAlmostEqual(x + y, 5.1 * ureg.meter)
+        self.assertQuantityAlmostEqual(z, 5.1 * ureg.meter)
 
     def _test_issueXX(self):
         ureg = UnitRegistry()
@@ -250,7 +250,7 @@ class TestIssues(TestCase):
 
 
 @helpers.requires_numpy()
-class TestIssuesNP(TestCase):
+class TestIssuesNP(QuantityTestCase):
 
     FORCE_NDARRAY = False
 
@@ -260,21 +260,21 @@ class TestIssuesNP(TestCase):
         ureg = UnitRegistry()
         q = ureg.meter * x
         self.assertIsInstance(q, ureg.Quantity)
-        self.assertSequenceEqual(q.magnitude, x)
+        np.testing.assert_array_equal(q.magnitude, x)
         self.assertEquals(q.units, ureg.meter.units)
         q = x * ureg.meter
         self.assertIsInstance(q, ureg.Quantity)
-        self.assertSequenceEqual(q.magnitude, x)
+        np.testing.assert_array_equal(q.magnitude, x)
         self.assertEquals(q.units, ureg.meter.units)
 
         m = np.ma.masked_array(2 * np.ones(3,3))
         qq = q * m
         self.assertIsInstance(qq, ureg.Quantity)
-        self.assertSequenceEqual(qq.magnitude, x * m)
+        np.testing.assert_array_equal(qq.magnitude, x * m)
         self.assertEquals(qq.units, ureg.meter.units)
         qq = m * q
         self.assertIsInstance(qq, ureg.Quantity)
-        self.assertSequenceEqual(qq.magnitude, x * m)
+        np.testing.assert_array_equal(qq.magnitude, x * m)
         self.assertEquals(qq.units, ureg.meter.units)
 
     @unittest.expectedFailure
@@ -283,29 +283,29 @@ class TestIssuesNP(TestCase):
         ureg = UnitRegistry()
         q = ureg.meter * x
         self.assertIsInstance(q, ureg.Quantity)
-        self.assertSequenceEqual(q.magnitude, x)
+        np.testing.assert_array_equal(q.magnitude, x)
         self.assertEquals(q.units, ureg.meter.units)
         q = x * ureg.meter
         self.assertIsInstance(q, ureg.Quantity)
-        self.assertSequenceEqual(q.magnitude, x)
+        np.testing.assert_array_equal(q.magnitude, x)
         self.assertEquals(q.units, ureg.meter.units)
 
         m = np.matrix(2 * np.ones(3,3))
         qq = q * m
         self.assertIsInstance(qq, ureg.Quantity)
-        self.assertSequenceEqual(qq.magnitude, x * m)
+        np.testing.assert_array_equal(qq.magnitude, x * m)
         self.assertEquals(qq.units, ureg.meter.units)
         qq = m * q
         self.assertIsInstance(qq, ureg.Quantity)
-        self.assertSequenceEqual(qq.magnitude, x * m)
+        np.testing.assert_array_equal(qq.magnitude, x * m)
         self.assertEquals(qq.units, ureg.meter.units)
 
     def test_issue44(self):
         ureg = UnitRegistry()
         x = 4. * ureg.dimensionless
         np.sqrt(x)
-        self.assertAlmostEqual(np.sqrt([4.] * ureg.dimensionless), [2.] * ureg.dimensionless)
-        self.assertAlmostEqual(np.sqrt(4. * ureg.dimensionless), 2. * ureg.dimensionless)
+        self.assertQuantityAlmostEqual(np.sqrt([4.] * ureg.dimensionless), [2.] * ureg.dimensionless)
+        self.assertQuantityAlmostEqual(np.sqrt(4. * ureg.dimensionless), 2. * ureg.dimensionless)
 
     def test_issue45(self):
         import math
@@ -336,20 +336,20 @@ class TestIssuesNP(TestCase):
         q1 = v1 * ureg.ms
         q2 = v2 * ureg.ms
 
-        self.assertSequenceEqual(q1 < q2, v1 < v2)
-        self.assertSequenceEqual(q1 > q2, v1 > v2)
+        np.testing.assert_array_equal(q1 < q2, v1 < v2)
+        np.testing.assert_array_equal(q1 > q2, v1 > v2)
 
-        self.assertSequenceEqual(q1 <= q2, v1 <= v2)
-        self.assertSequenceEqual(q1 >= q2, v1 >= v2)
+        np.testing.assert_array_equal(q1 <= q2, v1 <= v2)
+        np.testing.assert_array_equal(q1 >= q2, v1 >= v2)
 
         q2s = np.asarray([0.003, 0.002, 0.001]) * ureg.s
         v2s = q2s.to('ms').magnitude
 
-        self.assertSequenceEqual(q1 < q2s, v1 < v2s)
-        self.assertSequenceEqual(q1 > q2s, v1 > v2s)
+        np.testing.assert_array_equal(q1 < q2s, v1 < v2s)
+        np.testing.assert_array_equal(q1 > q2s, v1 > v2s)
 
-        self.assertSequenceEqual(q1 <= q2s, v1 <= v2s)
-        self.assertSequenceEqual(q1 >= q2s, v1 >= v2s)
+        np.testing.assert_array_equal(q1 <= q2s, v1 <= v2s)
+        np.testing.assert_array_equal(q1 >= q2s, v1 >= v2s)
 
     def test_issue75(self):
         ureg = UnitRegistry()
@@ -358,14 +358,14 @@ class TestIssuesNP(TestCase):
         q1 = v1 * ureg.ms
         q2 = v2 * ureg.ms
 
-        self.assertSequenceEqual(q1 == q2, v1 == v2)
-        self.assertSequenceEqual(q1 != q2, v1 != v2)
+        np.testing.assert_array_equal(q1 == q2, v1 == v2)
+        np.testing.assert_array_equal(q1 != q2, v1 != v2)
 
         q2s = np.asarray([0.003, 0.002, 0.001]) * ureg.s
         v2s = q2s.to('ms').magnitude
 
-        self.assertSequenceEqual(q1 == q2s, v1 == v2s)
-        self.assertSequenceEqual(q1 != q2s, v1 != v2s)
+        np.testing.assert_array_equal(q1 == q2s, v1 == v2s)
+        np.testing.assert_array_equal(q1 != q2s, v1 != v2s)
 
     def test_issue93(self):
         ureg = UnitRegistry()
@@ -379,8 +379,8 @@ class TestIssuesNP(TestCase):
         z += y
         self.assertIsInstance(z.magnitude, float)
 
-        self.assertAlmostEqual(x + y, 5.1 * ureg.meter)
-        self.assertAlmostEqual(z, 5.1 * ureg.meter)
+        self.assertQuantityAlmostEqual(x + y, 5.1 * ureg.meter)
+        self.assertQuantityAlmostEqual(z, 5.1 * ureg.meter)
 
 
     def test_issue94(self):
@@ -390,8 +390,8 @@ class TestIssuesNP(TestCase):
         v3 = np.array([5, 5]) * ureg.meter
         v3 += v2
 
-        self.assertSequenceEqual((v1 + v2).magnitude, np.array([5.1, 5.1]))
-        self.assertSequenceEqual(v3.magnitude, np.array([5, 5]))
+        np.testing.assert_array_equal((v1 + v2).magnitude, np.array([5.1, 5.1]))
+        np.testing.assert_array_equal(v3.magnitude, np.array([5, 5]))
 
     @helpers.requires_numpy18()
     def test_issue121(self):
@@ -407,10 +407,10 @@ class TestIssuesNP(TestCase):
         self.assertEqual(sum([v * ureg.meter, v * ureg.meter]), 2 * v * ureg.meter)
 
         z, v = np.zeros(sh), 2. * np.ones(sh)
-        self.assertSequenceEqual(z + v * ureg.meter, v * ureg.meter)
-        self.assertSequenceEqual(z - v * ureg.meter, -v * ureg.meter)
-        self.assertSequenceEqual(v * ureg.meter + z, v * ureg.meter)
-        self.assertSequenceEqual(v * ureg.meter - z, v * ureg.meter)
+        self.assertQuantityEqual(z + v * ureg.meter, v * ureg.meter)
+        self.assertQuantityEqual(z - v * ureg.meter, -v * ureg.meter)
+        self.assertQuantityEqual(v * ureg.meter + z, v * ureg.meter)
+        self.assertQuantityEqual(v * ureg.meter - z, v * ureg.meter)
 
         z, v = np.zeros((3, 1)), 2. * np.ones(sh)
         for x, y in ((z, v),
diff --git a/pint/testsuite/test_measurement.py b/pint/testsuite/test_measurement.py
index 2dc8bd7..89d9998 100644
--- a/pint/testsuite/test_measurement.py
+++ b/pint/testsuite/test_measurement.py
@@ -2,11 +2,11 @@
 
 from __future__ import division, unicode_literals, print_function, absolute_import
 
-from pint.testsuite import TestCase, helpers
+from pint.testsuite import QuantityTestCase, helpers
 
 
 @helpers.requires_not_uncertainties()
-class TestNotMeasurement(TestCase):
+class TestNotMeasurement(QuantityTestCase):
 
     FORCE_NDARRAY = False
 
@@ -16,7 +16,7 @@ class TestNotMeasurement(TestCase):
 
 
 @helpers.requires_uncertainties()
-class TestMeasurement(TestCase):
+class TestMeasurement(QuantityTestCase):
 
     FORCE_NDARRAY = False
 
diff --git a/pint/testsuite/test_numpy.py b/pint/testsuite/test_numpy.py
index 28fd42f..3b753d4 100644
--- a/pint/testsuite/test_numpy.py
+++ b/pint/testsuite/test_numpy.py
@@ -3,10 +3,11 @@
 from __future__ import division, unicode_literals, print_function, absolute_import
 
 from pint.compat import np, unittest
-from pint.testsuite import TestCase, helpers
+from pint.testsuite import QuantityTestCase, helpers
+
 
 @helpers.requires_numpy()
-class TestNumpyMethods(TestCase):
+class TestNumpyMethods(QuantityTestCase):
 
     FORCE_NDARRAY = True
 
@@ -19,86 +20,86 @@ class TestNumpyMethods(TestCase):
 
     def test_sum(self):
         self.assertEqual(self.q.sum(), 10*self.ureg.m)
-        self.assertSequenceEqual(self.q.sum(0), [4,     6]*self.ureg.m)
-        self.assertSequenceEqual(self.q.sum(1), [3, 7]*self.ureg.m)
+        self.assertQuantityEqual(self.q.sum(0), [4,     6]*self.ureg.m)
+        self.assertQuantityEqual(self.q.sum(1), [3, 7]*self.ureg.m)
 
     def test_fill(self):
         tmp = self.q
         tmp.fill(6 * self.ureg.ft)
-        self.assertSequenceEqual(tmp, [[6, 6], [6, 6]] * self.ureg.ft)
+        self.assertQuantityEqual(tmp, [[6, 6], [6, 6]] * self.ureg.ft)
         tmp.fill(5 * self.ureg.m)
-        self.assertSequenceEqual(tmp, [[5, 5], [5, 5]] * self.ureg.m)
+        self.assertQuantityEqual(tmp, [[5, 5], [5, 5]] * self.ureg.m)
 
     def test_reshape(self):
-        self.assertSequenceEqual(self.q.reshape([1,4]), [[1, 2, 3, 4]] * self.ureg.m)
+        self.assertQuantityEqual(self.q.reshape([1,4]), [[1, 2, 3, 4]] * self.ureg.m)
 
     def test_transpose(self):
-        self.assertSequenceEqual(self.q.transpose(), [[1, 3], [2, 4]] * self.ureg.m)
+        self.assertQuantityEqual(self.q.transpose(), [[1, 3], [2, 4]] * self.ureg.m)
 
     def test_flatten(self):
-        self.assertSequenceEqual(self.q.flatten(), [1, 2, 3, 4] * self.ureg.m)
+        self.assertQuantityEqual(self.q.flatten(), [1, 2, 3, 4] * self.ureg.m)
 
     def test_ravel(self):
-        self.assertSequenceEqual(self.q.ravel(), [1, 2, 3, 4] * self.ureg.m)
+        self.assertQuantityEqual(self.q.ravel(), [1, 2, 3, 4] * self.ureg.m)
 
     def test_squeeze(self):
-        self.assertSequenceEqual(
+        self.assertQuantityEqual(
             self.q.reshape([1,4]).squeeze(),
             [1, 2, 3, 4] * self.ureg.m
         )
 
     def test_take(self):
-        self.assertSequenceEqual(self.q.take([0,1,2,3]), self.q.flatten())
+        self.assertQuantityEqual(self.q.take([0,1,2,3]), self.q.flatten())
 
     def test_put(self):
         q =  [1., 2., 3., 4.] * self.ureg.m
         q.put([0, 2], [10.,20.]*self.ureg.m)
-        self.assertSequenceEqual(q, [10., 2., 20., 4.]*self.ureg.m)
+        self.assertQuantityEqual(q, [10., 2., 20., 4.]*self.ureg.m)
 
         q =  [1., 2., 3., 4.] * self.ureg.m
         q.put([0, 2], [1., 2.]*self.ureg.mm)
-        self.assertSequenceEqual(q, [0.001, 2., 0.002, 4.]*self.ureg.m)
+        self.assertQuantityEqual(q, [0.001, 2., 0.002, 4.]*self.ureg.m)
 
         q =  [1., 2., 3., 4.] * self.ureg.m / self.ureg.mm
         q.put([0, 2], [1., 2.])
-        self.assertSequenceEqual(q, [0.001, 2., 0.002, 4.]*self.ureg.m/self.ureg.mm)
+        self.assertQuantityEqual(q, [0.001, 2., 0.002, 4.]*self.ureg.m/self.ureg.mm)
 
         q =  [1., 2., 3., 4.] * self.ureg.m
         self.assertRaises(ValueError, q.put, [0, 2], [4., 6.] * self.ureg.J)
         self.assertRaises(ValueError, q.put, [0, 2], [4., 6.])
 
     def test_repeat(self):
-        self.assertSequenceEqual(self.q.repeat(2), [1,1,2,2,3,3,4,4]*self.ureg.m)
+        self.assertQuantityEqual(self.q.repeat(2), [1,1,2,2,3,3,4,4]*self.ureg.m)
 
     def test_sort(self):
         q = [4, 5, 2, 3, 1, 6] * self.ureg.m
         q.sort()
-        self.assertSequenceEqual(q, [1, 2, 3, 4, 5, 6] * self.ureg.m)
+        self.assertQuantityEqual(q, [1, 2, 3, 4, 5, 6] * self.ureg.m)
 
     def test_argsort(self):
         q = [1, 4, 5, 6, 2, 9] * self.ureg.MeV
-        self.assertSequenceEqual(q.argsort(), [0, 4, 1, 2, 3, 5])
+        np.testing.assert_array_equal(q.argsort(), [0, 4, 1, 2, 3, 5])
 
     def test_diagonal(self):
         q = [[1, 2, 3], [1, 2, 3], [1, 2, 3]] * self.ureg.m
-        self.assertSequenceEqual(q.diagonal(offset=1), [2, 3] * self.ureg.m)
+        self.assertQuantityEqual(q.diagonal(offset=1), [2, 3] * self.ureg.m)
 
     def test_compress(self):
-        self.assertSequenceEqual(self.q.compress([False, True], axis=0),
+        self.assertQuantityEqual(self.q.compress([False, True], axis=0),
                                  [[3, 4]] * self.ureg.m)
-        self.assertSequenceEqual(self.q.compress([False, True], axis=1),
+        self.assertQuantityEqual(self.q.compress([False, True], axis=1),
                                  [[2], [4]] * self.ureg.m)
 
     def test_searchsorted(self):
         q = self.q.flatten()
-        self.assertSequenceEqual(q.searchsorted([1.5, 2.5] * self.ureg.m),
-                                 [1, 2])
+        np.testing.assert_array_equal(q.searchsorted([1.5, 2.5] * self.ureg.m),
+                                      [1, 2])
         q = self.q.flatten()
         self.assertRaises(ValueError, q.searchsorted, [1.5, 2.5])
 
     def test_nonzero(self):
         q = [1, 0, 5, 6, 0, 9] * self.ureg.m
-        self.assertSequenceEqual(q.nonzero()[0], [0, 2, 3, 5])
+        np.testing.assert_array_equal(q.nonzero()[0], [0, 2, 3, 5])
 
     def test_max(self):
         self.assertEqual(self.q.max(), 4*self.ureg.m)
@@ -116,15 +117,15 @@ class TestNumpyMethods(TestCase):
         self.assertEqual(self.q.ptp(), 3 * self.ureg.m)
 
     def test_clip(self):
-        self.assertSequenceEqual(
+        self.assertQuantityEqual(
             self.q.clip(max=2*self.ureg.m),
             [[1, 2], [2, 2]] * self.ureg.m
         )
-        self.assertSequenceEqual(
+        self.assertQuantityEqual(
             self.q.clip(min=3*self.ureg.m),
             [[3, 3], [3, 4]] * self.ureg.m
         )
-        self.assertSequenceEqual(
+        self.assertQuantityEqual(
             self.q.clip(min=2*self.ureg.m, max=3*self.ureg.m),
             [[2, 2], [3, 3]] * self.ureg.m
         )
@@ -133,15 +134,15 @@ class TestNumpyMethods(TestCase):
 
     def test_round(self):
         q = [1, 1.33, 5.67, 22] * self.ureg.m
-        self.assertSequenceEqual(q.round(0), [1, 1, 6, 22] * self.ureg.m)
-        self.assertSequenceEqual(q.round(-1), [0, 0, 10, 20] * self.ureg.m)
-        self.assertSequenceEqual(q.round(1), [1, 1.3, 5.7, 22] * self.ureg.m)
+        self.assertQuantityEqual(q.round(0), [1, 1, 6, 22] * self.ureg.m)
+        self.assertQuantityEqual(q.round(-1), [0, 0, 10, 20] * self.ureg.m)
+        self.assertQuantityEqual(q.round(1), [1, 1.3, 5.7, 22] * self.ureg.m)
 
     def test_trace(self):
         self.assertEqual(self.q.trace(), (1+4) * self.ureg.m)
 
     def test_cumsum(self):
-        self.assertSequenceEqual(self.q.cumsum(), [1, 3, 6, 10] * self.ureg.m)
+        self.assertQuantityEqual(self.q.cumsum(), [1, 3, 6, 10] * self.ureg.m)
 
     def test_mean(self):
         self.assertEqual(self.q.mean(), 2.5 * self.ureg.m)
@@ -150,14 +151,14 @@ class TestNumpyMethods(TestCase):
         self.assertEqual(self.q.var(), 1.25*self.ureg.m**2)
 
     def test_std(self):
-        self.assertAlmostEqual(self.q.std(), 1.11803*self.ureg.m, delta=1e-5)
+        self.assertQuantityAlmostEqual(self.q.std(), 1.11803*self.ureg.m, rtol=1e-5)
 
     def test_prod(self):
         self.assertEqual(self.q.prod(), 24 * self.ureg.m**4)
 
     def test_cumprod(self):
         self.assertRaises(ValueError, self.q.cumprod)
-        self.assertSequenceEqual((self.q / self.ureg.m).cumprod(), [1, 2, 6, 24])
+        self.assertQuantityEqual((self.q / self.ureg.m).cumprod(), [1, 2, 6, 24])
 
     def test_integer_div(self):
         a = [1] * self.ureg.m
@@ -169,15 +170,15 @@ class TestNumpyMethods(TestCase):
         self.assertEqual(a.magnitude[0], 0)
 
     def test_conj(self):
-        self.assertSequenceEqual((self.q*(1+1j)).conj(), self.q*(1-1j))
-        self.assertSequenceEqual((self.q*(1+1j)).conjugate(), self.q*(1-1j))
+        self.assertQuantityEqual((self.q*(1+1j)).conj(), self.q*(1-1j))
+        self.assertQuantityEqual((self.q*(1+1j)).conjugate(), self.q*(1-1j))
 
     def test_getitem(self):
         self.assertRaises(IndexError, self.q.__getitem__, (0,10))
-        self.assertSequenceEqual(self.q[0], [1,2]*self.ureg.m)
+        self.assertQuantityEqual(self.q[0], [1,2]*self.ureg.m)
         self.assertEqual(self.q[1,1], 4*self.ureg.m)
 
-    def test_setitem (self):
+    def test_setitem(self):
         self.assertRaises(ValueError, self.q.__setitem__, (0,0), 1)
         self.assertRaises(ValueError, self.q.__setitem__, (0,0), 1*self.ureg.J)
         self.assertRaises(ValueError, self.q.__setitem__, 0, 1)
@@ -186,24 +187,24 @@ class TestNumpyMethods(TestCase):
 
         q = self.q.copy()
         q[0] = 1*self.ureg.m
-        self.assertSequenceEqual(q, [[1,1],[3,4]]*self.ureg.m)
+        self.assertQuantityEqual(q, [[1,1],[3,4]]*self.ureg.m)
 
         q[0] = (1,2)*self.ureg.m
-        self.assertSequenceEqual(q, self.q)
+        self.assertQuantityEqual(q, self.q)
 
         q[:] = 1*self.ureg.m
-        self.assertSequenceEqual(q, [[1,1],[1,1]]*self.ureg.m)
+        self.assertQuantityEqual(q, [[1,1],[1,1]]*self.ureg.m)
 
         # check and see that dimensionless num  bers work correctly
         q = [0,1,2,3]*self.ureg.dimensionless
         q[0] = 1
-        self.assertSequenceEqual(q, [1,1,2,3])
+        self.assertQuantityEqual(q, np.asarray([1,1,2,3]))
         q[0] = self.ureg.m/self.ureg.mm
-        self.assertSequenceEqual(q, [1000, 1,2,3])
+        self.assertQuantityEqual(q, np.asarray([1000, 1,2,3]))
 
-        q = [0.,1.,2.,3.] * self.ureg.m/self.ureg.mm
+        q = [0.,1.,2.,3.] * self.ureg.m / self.ureg.mm
         q[0] = 1.
-        self.assertQuantityEqual(q, [0.001,1,2,3]*self.ureg.m/self.ureg.mm)
+        self.assertQuantityEqual(q, [0.001,1,2,3]*self.ureg.m / self.ureg.mm)
 
     def test_iterator(self):
         for q, v in zip(self.q.flatten(), [1, 2, 3, 4]):
@@ -214,17 +215,17 @@ class TestNumpyMethods(TestCase):
         """
         x = self.q.magnitude
         u = self.Q_(np.ones(x.shape))
-        self.assertSequenceEqual(x / self.q, u * x / self.q)
-        self.assertSequenceEqual(x * self.q, u * x * self.q)
-        self.assertSequenceEqual(x + u, u + x)
-        self.assertSequenceEqual(x - u, -(u - x))
+        self.assertQuantityEqual(x / self.q, u * x / self.q)
+        self.assertQuantityEqual(x * self.q, u * x * self.q)
+        self.assertQuantityEqual(x + u, u + x)
+        self.assertQuantityEqual(x - u, -(u - x))
 
     def test_pickle(self):
         import pickle
 
         def pickle_test(q):
             pq = pickle.loads(pickle.dumps(q))
-            self.assertSequenceEqual(q.magnitude, pq.magnitude)
+            np.testing.assert_array_equal(q.magnitude, pq.magnitude)
             self.assertEqual(q.units, pq.units)
 
         pickle_test([10,20]*self.ureg.m)
@@ -233,9 +234,9 @@ class TestNumpyMethods(TestCase):
         x = self.q.magnitude
         u = self.Q_(np.ones(x.shape))
 
-        self.assertSequenceEqual(u, u)
-        self.assertSequenceEqual(u == u, u.magnitude == u.magnitude)
-        self.assertSequenceEqual(u == 1, u.magnitude == 1)
+        self.assertQuantityEqual(u, u)
+        self.assertQuantityEqual(u == u, u.magnitude == u.magnitude)
+        self.assertQuantityEqual(u == 1, u.magnitude == 1)
 
 
 from pint.testsuite.test_umath import TestUFuncs
@@ -259,7 +260,7 @@ class TestNumpyNotSupported(TestUFuncs):
     def test_diff(self):
         """Units are erased by asanyarray, Quantity does not inherit from NDArray
         """
-        self.assertSequenceEqual(np.diff(self.q, 1), [1, 1, 1] * self.ureg.J)
+        self.assertQuantityEqual(np.diff(self.q, 1), [1, 1, 1] * self.ureg.J)
 
     def test_ediff1d(self):
         """Units are erased by asanyarray, Quantity does not inherit from NDArray
@@ -271,7 +272,7 @@ class TestNumpyNotSupported(TestUFuncs):
         """
         self.assertEqual(np.fix(3.14 * self.ureg.m), 3.0 * self.ureg.m)
         self.assertEqual(np.fix(3.0 * self.ureg.m), 3.0 * self.ureg.m)
-        self.assertSequenceEqual(
+        self.assertQuantityEqual(
             np.fix([2.1, 2.9, -2.1, -2.9] * self.ureg.m),
             [2., 2., -2., -2.] * self.ureg.m
         )
@@ -288,7 +289,7 @@ class TestNumpyNotSupported(TestUFuncs):
         """
         a = [3,-3, 1] * self.ureg.kPa
         b = [4, 9, 2] * self.ureg.m**2
-        self.assertSequenceEqual(np.cross(a,b), [-15,-2,39]*self.ureg.kPa*self.ureg.m**2)
+        self.assertQuantityEqual(np.cross(a,b), [-15,-2,39]*self.ureg.kPa*self.ureg.m**2)
 
     def test_power(self):
         """This is not supported as different elements might end up with different units
diff --git a/pint/testsuite/test_pitheorem.py b/pint/testsuite/test_pitheorem.py
index 3f5a2a1..c489431 100644
--- a/pint/testsuite/test_pitheorem.py
+++ b/pint/testsuite/test_pitheorem.py
@@ -6,10 +6,10 @@ import itertools
 
 from pint import pi_theorem
 
-from pint.testsuite import TestCase
+from pint.testsuite import QuantityTestCase
 
 
-class TestPiTheorem(TestCase):
+class TestPiTheorem(QuantityTestCase):
 
     FORCE_NDARRAY = False
 
diff --git a/pint/testsuite/test_quantity.py b/pint/testsuite/test_quantity.py
index f49b1c7..6e5ae12 100644
--- a/pint/testsuite/test_quantity.py
+++ b/pint/testsuite/test_quantity.py
@@ -9,10 +9,10 @@ import operator as op
 from pint import DimensionalityError, UnitRegistry
 from pint.unit import UnitsContainer
 from pint.compat import string_types, PYTHON3, np
-from pint.testsuite import TestCase, helpers
+from pint.testsuite import QuantityTestCase, helpers
 
 
-class TestQuantity(TestCase):
+class TestQuantity(QuantityTestCase):
 
     FORCE_NDARRAY = False
 
@@ -123,24 +123,24 @@ class TestQuantity(TestCase):
 
     def test_to_base_units(self):
         x = self.Q_('1*inch')
-        self.assertAlmostEqual(x.to_base_units(), self.Q_(0.0254, 'meter'))
+        self.assertQuantityAlmostEqual(x.to_base_units(), self.Q_(0.0254, 'meter'))
         x = self.Q_('1*inch*inch')
-        self.assertAlmostEqual(x.to_base_units(), self.Q_(0.0254 ** 2.0, 'meter*meter'))
+        self.assertQuantityAlmostEqual(x.to_base_units(), self.Q_(0.0254 ** 2.0, 'meter*meter'))
         x = self.Q_('1*inch/minute')
-        self.assertAlmostEqual(x.to_base_units(), self.Q_(0.0254 / 60., 'meter/second'))
+        self.assertQuantityAlmostEqual(x.to_base_units(), self.Q_(0.0254 / 60., 'meter/second'))
 
     def test_convert(self):
         x = self.Q_('2*inch')
-        self.assertAlmostEqual(x.to('meter'), self.Q_(2. * 0.0254, 'meter'))
+        self.assertQuantityAlmostEqual(x.to('meter'), self.Q_(2. * 0.0254, 'meter'))
         x = self.Q_('2*meter')
-        self.assertAlmostEqual(x.to('inch'), self.Q_(2. / 0.0254, 'inch'))
+        self.assertQuantityAlmostEqual(x.to('inch'), self.Q_(2. / 0.0254, 'inch'))
         x = self.Q_('2*sidereal_second')
-        self.assertAlmostEqual(x.to('second'), self.Q_(1.994539133 , 'second'))
+        self.assertQuantityAlmostEqual(x.to('second'), self.Q_(1.994539133 , 'second'))
         x = self.Q_('2.54*centimeter/second')
-        self.assertAlmostEqual(x.to('inch/second'), self.Q_(1, 'inch/second'))
+        self.assertQuantityAlmostEqual(x.to('inch/second'), self.Q_(1, 'inch/second'))
         x = self.Q_('2.54*centimeter')
-        self.assertAlmostEqual(x.to('inch').magnitude, 1)
-        self.assertAlmostEqual(self.Q_(2, 'second').to('millisecond').magnitude, 2000)
+        self.assertQuantityAlmostEqual(x.to('inch').magnitude, 1)
+        self.assertQuantityAlmostEqual(self.Q_(2, 'second').to('millisecond').magnitude, 2000)
 
     @helpers.requires_numpy()
     def test_convert(self):
@@ -178,48 +178,48 @@ class TestQuantity(TestCase):
         self.assertEqual((self.Q_(1, 'meter')/self.Q_(1, 'mm')).to(''), 1000)
 
     def test_offset(self):
-        self.assertAlmostEqual(self.Q_(0, 'kelvin').to('kelvin'), self.Q_(0, 'kelvin'))
-        self.assertAlmostEqual(self.Q_(0, 'degC').to('kelvin'), self.Q_(273.15, 'kelvin'))
-        self.assertAlmostEqual(self.Q_(0, 'degF').to('kelvin'), self.Q_(255.372222, 'kelvin'), places=2)
+        self.assertQuantityAlmostEqual(self.Q_(0, 'kelvin').to('kelvin'), self.Q_(0, 'kelvin'))
+        self.assertQuantityAlmostEqual(self.Q_(0, 'degC').to('kelvin'), self.Q_(273.15, 'kelvin'))
+        self.assertQuantityAlmostEqual(self.Q_(0, 'degF').to('kelvin'), self.Q_(255.372222, 'kelvin'), rtol=0.01)
 
-        self.assertAlmostEqual(self.Q_(100, 'kelvin').to('kelvin'), self.Q_(100, 'kelvin'))
-        self.assertAlmostEqual(self.Q_(100, 'degC').to('kelvin'), self.Q_(373.15, 'kelvin'))
-        self.assertAlmostEqual(self.Q_(100, 'degF').to('kelvin'), self.Q_(310.92777777, 'kelvin'), places=2)
+        self.assertQuantityAlmostEqual(self.Q_(100, 'kelvin').to('kelvin'), self.Q_(100, 'kelvin'))
+        self.assertQuantityAlmostEqual(self.Q_(100, 'degC').to('kelvin'), self.Q_(373.15, 'kelvin'))
+        self.assertQuantityAlmostEqual(self.Q_(100, 'degF').to('kelvin'), self.Q_(310.92777777, 'kelvin'), rtol=0.01)
 
-        self.assertAlmostEqual(self.Q_(0, 'kelvin').to('degC'), self.Q_(-273.15, 'degC'))
-        self.assertAlmostEqual(self.Q_(100, 'kelvin').to('degC'), self.Q_(-173.15, 'degC'))
-        self.assertAlmostEqual(self.Q_(0, 'kelvin').to('degF'), self.Q_(-459.67, 'degF'), 2)
-        self.assertAlmostEqual(self.Q_(100, 'kelvin').to('degF'), self.Q_(-279.67, 'degF'), 2)
+        self.assertQuantityAlmostEqual(self.Q_(0, 'kelvin').to('degC'), self.Q_(-273.15, 'degC'))
+        self.assertQuantityAlmostEqual(self.Q_(100, 'kelvin').to('degC'), self.Q_(-173.15, 'degC'))
+        self.assertQuantityAlmostEqual(self.Q_(0, 'kelvin').to('degF'), self.Q_(-459.67, 'degF'), rtol=0.01)
+        self.assertQuantityAlmostEqual(self.Q_(100, 'kelvin').to('degF'), self.Q_(-279.67, 'degF'), rtol=0.01)
 
-        self.assertAlmostEqual(self.Q_(32, 'degF').to('degC'), self.Q_(0, 'degC'), 2)
-        self.assertAlmostEqual(self.Q_(100, 'degC').to('degF'), self.Q_(212, 'degF'), 2)
+        self.assertQuantityAlmostEqual(self.Q_(32, 'degF').to('degC'), self.Q_(0, 'degC'), atol=0.01)
+        self.assertQuantityAlmostEqual(self.Q_(100, 'degC').to('degF'), self.Q_(212, 'degF'), atol=0.01)
 
-        self.assertAlmostEqual(self.Q_(54, 'degF').to('degC'), self.Q_(12.2222, 'degC'), 2)
-        self.assertAlmostEqual(self.Q_(12, 'degC').to('degF'), self.Q_(53.6, 'degF'), 2)
+        self.assertQuantityAlmostEqual(self.Q_(54, 'degF').to('degC'), self.Q_(12.2222, 'degC'), atol=0.01)
+        self.assertQuantityAlmostEqual(self.Q_(12, 'degC').to('degF'), self.Q_(53.6, 'degF'), atol=0.01)
 
-        self.assertAlmostEqual(self.Q_(12, 'kelvin').to('degC'), self.Q_(-261.15, 'degC'), 2)
-        self.assertAlmostEqual(self.Q_(12, 'degC').to('kelvin'), self.Q_(285.15, 'kelvin'), 2)
+        self.assertQuantityAlmostEqual(self.Q_(12, 'kelvin').to('degC'), self.Q_(-261.15, 'degC'), atol=0.01)
+        self.assertQuantityAlmostEqual(self.Q_(12, 'degC').to('kelvin'), self.Q_(285.15, 'kelvin'), atol=0.01)
 
-        self.assertAlmostEqual(self.Q_(12, 'kelvin').to('degR'), self.Q_(21.6, 'degR'), 2)
-        self.assertAlmostEqual(self.Q_(12, 'degR').to('kelvin'), self.Q_(6.66666667, 'kelvin'), 2)
+        self.assertQuantityAlmostEqual(self.Q_(12, 'kelvin').to('degR'), self.Q_(21.6, 'degR'), atol=0.01)
+        self.assertQuantityAlmostEqual(self.Q_(12, 'degR').to('kelvin'), self.Q_(6.66666667, 'kelvin'), atol=0.01)
 
-        self.assertAlmostEqual(self.Q_(12, 'degC').to('degR'), self.Q_(513.27, 'degR'), 2)
-        self.assertAlmostEqual(self.Q_(12, 'degR').to('degC'), self.Q_(-266.483333, 'degC'), 2)
+        self.assertQuantityAlmostEqual(self.Q_(12, 'degC').to('degR'), self.Q_(513.27, 'degR'), atol=0.01)
+        self.assertQuantityAlmostEqual(self.Q_(12, 'degR').to('degC'), self.Q_(-266.483333, 'degC'), atol=0.01)
 
 
     def test_offset_delta(self):
-        self.assertAlmostEqual(self.Q_(0, 'delta_kelvin').to('delta_kelvin'), self.Q_(0, 'delta_kelvin'))
-        self.assertAlmostEqual(self.Q_(0, 'delta_degC').to('delta_kelvin'), self.Q_(0, 'delta_kelvin'))
-        self.assertAlmostEqual(self.Q_(0, 'delta_degF').to('delta_kelvin'), self.Q_(0, 'delta_kelvin'), places=2)
+        self.assertQuantityAlmostEqual(self.Q_(0, 'delta_kelvin').to('delta_kelvin'), self.Q_(0, 'delta_kelvin'))
+        self.assertQuantityAlmostEqual(self.Q_(0, 'delta_degC').to('delta_kelvin'), self.Q_(0, 'delta_kelvin'))
+        self.assertQuantityAlmostEqual(self.Q_(0, 'delta_degF').to('delta_kelvin'), self.Q_(0, 'delta_kelvin'), rtol=0.01)
 
-        self.assertAlmostEqual(self.Q_(100, 'delta_kelvin').to('delta_kelvin'), self.Q_(100, 'delta_kelvin'))
-        self.assertAlmostEqual(self.Q_(100, 'delta_kelvin').to('delta_degC'), self.Q_(100, 'delta_degC'))
-        self.assertAlmostEqual(self.Q_(100, 'delta_kelvin').to('delta_degF'), self.Q_(180, 'delta_degF'), places=2)
-        self.assertAlmostEqual(self.Q_(100, 'delta_degF').to('delta_kelvin'), self.Q_(55.55555556, 'delta_kelvin'), places=2)
-        self.assertAlmostEqual(self.Q_(100, 'delta_degC').to('delta_degF'), self.Q_(180, 'delta_degF'), places=2)
-        self.assertAlmostEqual(self.Q_(100, 'delta_degF').to('delta_degC'), self.Q_(55.55555556, 'delta_degC'), places=2)
+        self.assertQuantityAlmostEqual(self.Q_(100, 'delta_kelvin').to('delta_kelvin'), self.Q_(100, 'delta_kelvin'))
+        self.assertQuantityAlmostEqual(self.Q_(100, 'delta_kelvin').to('delta_degC'), self.Q_(100, 'delta_degC'))
+        self.assertQuantityAlmostEqual(self.Q_(100, 'delta_kelvin').to('delta_degF'), self.Q_(180, 'delta_degF'), rtol=0.01)
+        self.assertQuantityAlmostEqual(self.Q_(100, 'delta_degF').to('delta_kelvin'), self.Q_(55.55555556, 'delta_kelvin'), rtol=0.01)
+        self.assertQuantityAlmostEqual(self.Q_(100, 'delta_degC').to('delta_degF'), self.Q_(180, 'delta_degF'), rtol=0.01)
+        self.assertQuantityAlmostEqual(self.Q_(100, 'delta_degF').to('delta_degC'), self.Q_(55.55555556, 'delta_degC'), rtol=0.01)
 
-        self.assertAlmostEqual(self.Q_(12.3, 'delta_degC').to('delta_degF'), self.Q_(22.14, 'delta_degF'), places=2)
+        self.assertQuantityAlmostEqual(self.Q_(12.3, 'delta_degC').to('delta_degF'), self.Q_(22.14, 'delta_degF'), rtol=0.01)
 
 
     def test_pickle(self):
@@ -234,7 +234,7 @@ class TestQuantity(TestCase):
         pickle_test(self.Q_(2.4, 'm/s'))
 
 
-class TestQuantityBasicMath(TestCase):
+class TestQuantityBasicMath(QuantityTestCase):
 
     FORCE_NDARRAY = False
 
@@ -404,7 +404,7 @@ class TestQuantityBasicMath(TestCase):
             self.assertRaises(DimensionalityError, fun, z)
 
 
-class TestDimensions(TestCase):
+class TestDimensions(QuantityTestCase):
 
     FORCE_NDARRAY = False
 
diff --git a/pint/testsuite/test_umath.py b/pint/testsuite/test_umath.py
index 3f8042d..04688f4 100644
--- a/pint/testsuite/test_umath.py
+++ b/pint/testsuite/test_umath.py
@@ -3,7 +3,7 @@
 from __future__ import division, unicode_literals, print_function, absolute_import
 
 from pint.compat import np
-from pint.testsuite import TestCase, helpers
+from pint.testsuite import QuantityTestCase, helpers
 
 # Following http://docs.scipy.org/doc/numpy/reference/ufuncs.html
 
@@ -12,7 +12,7 @@ if np:
 
 
 @helpers.requires_numpy()
-class TestUFuncs(TestCase):
+class TestUFuncs(QuantityTestCase):
 
     FORCE_NDARRAY = True
 
diff --git a/pint/testsuite/test_unit.py b/pint/testsuite/test_unit.py
index 433254e..733e208 100644
--- a/pint/testsuite/test_unit.py
+++ b/pint/testsuite/test_unit.py
@@ -13,7 +13,7 @@ from pint.unit import (ScaleConverter, OffsetConverter, UnitsContainer,
                        LazyRegistry, ParserHelper)
 from pint import DimensionalityError, UndefinedUnitError
 from pint.compat import u, unittest, np
-from pint.testsuite import TestCase, logger, TestHandler, helpers
+from pint.testsuite import QuantityTestCase, helpers
 
 
 class TestConverter(unittest.TestCase):
@@ -119,7 +119,7 @@ class TestDefinition(unittest.TestCase):
         self.assertEqual(x.reference, UnitsContainer({'[length]': 1, '[time]': -1}))
 
 
-class TestUnitsContainer(unittest.TestCase):
+class TestUnitsContainer(QuantityTestCase):
 
     def _test_inplace(self, operator, value1, value2, expected_result):
         value1 = copy.copy(value1)
@@ -128,9 +128,9 @@ class TestUnitsContainer(unittest.TestCase):
         id2 = id(value2)
         value1 = operator(value1, value2)
         value2_cpy = copy.copy(value2)
-        self.assertAlmostEqual(value1, expected_result)
+        self.assertEqual(value1, expected_result)
         self.assertEqual(id1, id(value1))
-        self.assertAlmostEqual(value2, value2_cpy)
+        self.assertEqual(value2, value2_cpy)
         self.assertEqual(id2, id(value2))
 
     def _test_not_inplace(self, operator, value1, value2, expected_result):
@@ -142,9 +142,9 @@ class TestUnitsContainer(unittest.TestCase):
 
         result = operator(value1, value2)
 
-        self.assertAlmostEqual(expected_result, result)
-        self.assertAlmostEqual(value1, value1_cpy)
-        self.assertAlmostEqual(value2, value2_cpy)
+        self.assertEqual(expected_result, result)
+        self.assertEqual(value1, value1_cpy)
+        self.assertEqual(value2, value2_cpy)
         self.assertNotEqual(id(result), id1)
         self.assertNotEqual(id(result), id2)
 
@@ -227,7 +227,7 @@ class TestUnitsContainer(unittest.TestCase):
         self.assertRaises(TypeError, d.__rtruediv__, list())
 
 
-class TestRegistry(TestCase):
+class TestRegistry(QuantityTestCase):
 
     FORCE_NDARRAY = False
 
@@ -450,17 +450,16 @@ class TestRegistry(TestCase):
     def test_redefinition(self):
         d = UnitRegistry().define
 
-        th = TestHandler()
-        logger.addHandler(th)
-        d('meter = [fruits]')
-        d('kilo- = 1000')
-        d('[speed] = [vegetables]')
+        with self.capture_log() as buffer:
+            d('meter = [fruits]')
+            d('kilo- = 1000')
+            d('[speed] = [vegetables]')
 
-        # aliases
-        d('bla = 3.2 meter = inch')
-        d('myk- = 1000 = kilo-')
+            # aliases
+            d('bla = 3.2 meter = inch')
+            d('myk- = 1000 = kilo-')
 
-        self.assertEqual(len(th.buffer), 5)
+            self.assertEqual(len(buffer), 5)
 
     def test_convert_parse_str(self):
         ureg = self.ureg
@@ -495,7 +494,7 @@ class TestRegistry(TestCase):
         self.assertRaises(ValueError, ureg.parse_units, '2 * meter')
 
 
-class TestCompatibleUnits(TestCase):
+class TestCompatibleUnits(QuantityTestCase):
 
     FORCE_NDARRAY= False