third_party/Python/module/unittest2/unittest2/test/test_assertions.py

   1 import datetime
   2
   3 import unittest2
   4
   5
   6 class Test_Assertions(unittest2.TestCase):
   7     def test_AlmostEqual(self):
   8         self.assertAlmostEqual(1.00000001, 1.0)
   9         self.assertNotAlmostEqual(1.0000001, 1.0)
  10         self.assertRaises(self.failureException,
  11                           self.assertAlmostEqual, 1.0000001, 1.0)
  12         self.assertRaises(self.failureException,
  13                           self.assertNotAlmostEqual, 1.00000001, 1.0)
  14
  15         self.assertAlmostEqual(1.1, 1.0, places=0)
  16         self.assertRaises(self.failureException,
  17                           self.assertAlmostEqual, 1.1, 1.0, places=1)
  18
  19         self.assertAlmostEqual(0, .1+.1j, places=0)
  20         self.assertNotAlmostEqual(0, .1+.1j, places=1)
  21         self.assertRaises(self.failureException,
  22                           self.assertAlmostEqual, 0, .1+.1j, places=1)
  23         self.assertRaises(self.failureException,
  24                           self.assertNotAlmostEqual, 0, .1+.1j, places=0)
  25
  26         try:
  27             self.assertAlmostEqual(float('inf'), float('inf'))
  28             self.assertRaises(self.failureException, self.assertNotAlmostEqual,
  29                               float('inf'), float('inf'))
  30         except ValueError:
  31             # float('inf') is invalid on Windows in Python 2.4 / 2.5
  32             x = object()
  33             self.assertAlmostEqual(x, x)
  34             self.assertRaises(self.failureException, self.assertNotAlmostEqual,
  35                               x, x)
  36
  37
  38     def test_AmostEqualWithDelta(self):
  39         self.assertAlmostEqual(1.1, 1.0, delta=0.5)
  40         self.assertAlmostEqual(1.0, 1.1, delta=0.5)
  41         self.assertNotAlmostEqual(1.1, 1.0, delta=0.05)
  42         self.assertNotAlmostEqual(1.0, 1.1, delta=0.05)
  43
  44         self.assertRaises(self.failureException, self.assertAlmostEqual,
  45                           1.1, 1.0, delta=0.05)
  46         self.assertRaises(self.failureException, self.assertNotAlmostEqual,
  47                           1.1, 1.0, delta=0.5)
  48
  49         self.assertRaises(TypeError, self.assertAlmostEqual,
  50                           1.1, 1.0, places=2, delta=2)
  51         self.assertRaises(TypeError, self.assertNotAlmostEqual,
  52                           1.1, 1.0, places=2, delta=2)
  53
  54         first = datetime.datetime.now()
  55         second = first + datetime.timedelta(seconds=10)
  56         self.assertAlmostEqual(first, second,
  57                                delta=datetime.timedelta(seconds=20))
  58         self.assertNotAlmostEqual(first, second,
  59                                   delta=datetime.timedelta(seconds=5))
  60
  61     def testAssertNotRegexpMatches(self):
  62         self.assertNotRegexpMatches('Ala ma kota', r'r+')
  63         try:
  64             self.assertNotRegexpMatches('Ala ma kota', r'k.t', 'Message')
  65         except self.failureException as e:
  66             self.assertIn("'kot'", e.args[0])
  67             self.assertIn('Message', e.args[0])
  68         else:
  69             self.fail('assertNotRegexpMatches should have failed.')
  70
  71
  72 class TestLongMessage(unittest2.TestCase):
  73     """Test that the individual asserts honour longMessage.
  74     This actually tests all the message behaviour for
  75     asserts that use longMessage."""
  76
  77     def setUp(self):
  78         class TestableTestFalse(unittest2.TestCase):
  79             longMessage = False
  80             failureException = self.failureException
  81
  82             def testTest(self):
  83                 pass
  84
  85         class TestableTestTrue(unittest2.TestCase):
  86             longMessage = True
  87             failureException = self.failureException
  88
  89             def testTest(self):
  90                 pass
  91
  92         self.testableTrue = TestableTestTrue('testTest')
  93         self.testableFalse = TestableTestFalse('testTest')
  94
  95     def testDefault(self):
  96         self.assertTrue(unittest2.TestCase.longMessage)
  97
  98     def test_formatMsg(self):
  99         self.assertEquals(self.testableFalse._formatMessage(None, "foo"), "foo")
 100         self.assertEquals(self.testableFalse._formatMessage("foo", "bar"), "foo")
 101
 102         self.assertEquals(self.testableTrue._formatMessage(None, "foo"), "foo")
 103         self.assertEquals(self.testableTrue._formatMessage("foo", "bar"), "bar : foo")
 104
 105         # This blows up if _formatMessage uses string concatenation
 106         self.testableTrue._formatMessage(object(), 'foo')
 107
 108     def assertMessages(self, methodName, args, errors):
 109         def getMethod(i):
 110             useTestableFalse  = i < 2
 111             if useTestableFalse:
 112                 test = self.testableFalse
 113             else:
 114                 test = self.testableTrue
 115             return getattr(test, methodName)
 116
 117         for i, expected_regexp in enumerate(errors):
 118             testMethod = getMethod(i)
 119             kwargs = {}
 120             withMsg = i % 2
 121             if withMsg:
 122                 kwargs = {"msg": "oops"}
 123
 124             self.assertRaisesRegexp(self.failureException,
 125                                     expected_regexp,
 126                                     lambda: testMethod(*args, **kwargs))
 127
 128     def testAssertTrue(self):
 129         self.assertMessages('assertTrue', (False,),
 130                             ["^False is not True$", "^oops$", "^False is not True$",
 131                              "^False is not True : oops$"])
 132
 133     def testAssertFalse(self):
 134         self.assertMessages('assertFalse', (True,),
 135                             ["^True is not False$", "^oops$", "^True is not False$",
 136                              "^True is not False : oops$"])
 137
 138     def testNotEqual(self):
 139         self.assertMessages('assertNotEqual', (1, 1),
 140                             ["^1 == 1$", "^oops$", "^1 == 1$",
 141                              "^1 == 1 : oops$"])
 142
 143     def testAlmostEqual(self):
 144         self.assertMessages('assertAlmostEqual', (1, 2),
 145                             ["^1 != 2 within 7 places$", "^oops$",
 146                              "^1 != 2 within 7 places$", "^1 != 2 within 7 places : oops$"])
 147
 148     def testNotAlmostEqual(self):
 149         self.assertMessages('assertNotAlmostEqual', (1, 1),
 150                             ["^1 == 1 within 7 places$", "^oops$",
 151                              "^1 == 1 within 7 places$", "^1 == 1 within 7 places : oops$"])
 152
 153     def test_baseAssertEqual(self):
 154         self.assertMessages('_baseAssertEqual', (1, 2),
 155                             ["^1 != 2$", "^oops$", "^1 != 2$", "^1 != 2 : oops$"])
 156
 157     def testAssertSequenceEqual(self):
 158         # Error messages are multiline so not testing on full message
 159         # assertTupleEqual and assertListEqual delegate to this method
 160         self.assertMessages('assertSequenceEqual', ([], [None]),
 161                             ["\+ \[None\]$", "^oops$", r"\+ \[None\]$",
 162                              r"\+ \[None\] : oops$"])
 163
 164     def testAssertSetEqual(self):
 165         self.assertMessages('assertSetEqual', (set(), set([None])),
 166                             ["None$", "^oops$", "None$",
 167                              "None : oops$"])
 168
 169     def testAssertIn(self):
 170         self.assertMessages('assertIn', (None, []),
 171                             ['^None not found in \[\]$', "^oops$",
 172                              '^None not found in \[\]$',
 173                              '^None not found in \[\] : oops$'])
 174
 175     def testAssertNotIn(self):
 176         self.assertMessages('assertNotIn', (None, [None]),
 177                             ['^None unexpectedly found in \[None\]$', "^oops$",
 178                              '^None unexpectedly found in \[None\]$',
 179                              '^None unexpectedly found in \[None\] : oops$'])
 180
 181     def testAssertDictEqual(self):
 182         self.assertMessages('assertDictEqual', ({}, {'key': 'value'}),
 183                             [r"\+ \{'key': 'value'\}$", "^oops$",
 184                              "\+ \{'key': 'value'\}$",
 185                              "\+ \{'key': 'value'\} : oops$"])
 186
 187     def testAssertDictContainsSubset(self):
 188         self.assertMessages('assertDictContainsSubset', ({'key': 'value'}, {}),
 189                             ["^Missing: 'key'$", "^oops$",
 190                              "^Missing: 'key'$",
 191                              "^Missing: 'key' : oops$"])
 192
 193     def testAssertItemsEqual(self):
 194         self.assertMessages('assertItemsEqual', ([], [None]),
 195                             [r"\[None\]$", "^oops$",
 196                              r"\[None\]$",
 197                              r"\[None\] : oops$"])
 198
 199     def testAssertMultiLineEqual(self):
 200         self.assertMessages('assertMultiLineEqual', ("", "foo"),
 201                             [r"\+ foo$", "^oops$",
 202                              r"\+ foo$",
 203                              r"\+ foo : oops$"])
 204
 205     def testAssertLess(self):
 206         self.assertMessages('assertLess', (2, 1),
 207                             ["^2 not less than 1$", "^oops$",
 208                              "^2 not less than 1$", "^2 not less than 1 : oops$"])
 209
 210     def testAssertLessEqual(self):
 211         self.assertMessages('assertLessEqual', (2, 1),
 212                             ["^2 not less than or equal to 1$", "^oops$",
 213                              "^2 not less than or equal to 1$",
 214                              "^2 not less than or equal to 1 : oops$"])
 215
 216     def testAssertGreater(self):
 217         self.assertMessages('assertGreater', (1, 2),
 218                             ["^1 not greater than 2$", "^oops$",
 219                              "^1 not greater than 2$",
 220                              "^1 not greater than 2 : oops$"])
 221
 222     def testAssertGreaterEqual(self):
 223         self.assertMessages('assertGreaterEqual', (1, 2),
 224                             ["^1 not greater than or equal to 2$", "^oops$",
 225                              "^1 not greater than or equal to 2$",
 226                              "^1 not greater than or equal to 2 : oops$"])
 227
 228     def testAssertIsNone(self):
 229         self.assertMessages('assertIsNone', ('not None',),
 230                             ["^'not None' is not None$", "^oops$",
 231                              "^'not None' is not None$",
 232                              "^'not None' is not None : oops$"])
 233
 234     def testAssertIsNotNone(self):
 235         self.assertMessages('assertIsNotNone', (None,),
 236                             ["^unexpectedly None$", "^oops$",
 237                              "^unexpectedly None$",
 238                              "^unexpectedly None : oops$"])
 239
 240     def testAssertIs(self):
 241         self.assertMessages('assertIs', (None, 'foo'),
 242                             ["^None is not 'foo'$", "^oops$",
 243                              "^None is not 'foo'$",
 244                              "^None is not 'foo' : oops$"])
 245
 246     def testAssertIsNot(self):
 247         self.assertMessages('assertIsNot', (None, None),
 248                             ["^unexpectedly identical: None$", "^oops$",
 249                              "^unexpectedly identical: None$",
 250                              "^unexpectedly identical: None : oops$"])
 251
 252
 253 if __name__ == '__main__':
 254     unittest2.main()