Zy Filemanager

📁 File Browser

Name	Size	Permissions	Actions
📄 __init__.py (514 bytes)	514 B	0644	✍️ ⬇️ 🗑️
📄 __init__.pyc (906 bytes)	906 B	0644	✍️ ⬇️ 🗑️
📄 __init__.pyo (906 bytes)	906 B	0644	✍️ ⬇️ 🗑️
📄 dummy.py (50 bytes)	50 B	0644	✍️ ⬇️ 🗑️
📄 dummy.pyc (130 bytes)	130 B	0644	✍️ ⬇️ 🗑️
📄 dummy.pyo (130 bytes)	130 B	0644	✍️ ⬇️ 🗑️
📄 support.py (3,471 bytes)	3.39 KB	0644	✍️ ⬇️ 🗑️
📄 support.pyc (6,004 bytes)	5.86 KB	0644	✍️ ⬇️ 🗑️
📄 support.pyo (6,004 bytes)	5.86 KB	0644	✍️ ⬇️ 🗑️
📄 test_assertions.py (11,961 bytes)	11.68 KB	0644	✍️ ⬇️ 🗑️
📄 test_assertions.pyc (13,434 bytes)	13.12 KB	0644	✍️ ⬇️ 🗑️
📄 test_assertions.pyo (13,434 bytes)	13.12 KB	0644	✍️ ⬇️ 🗑️
📄 test_break.py (9,641 bytes)	9.42 KB	0644	✍️ ⬇️ 🗑️
📄 test_break.pyc (10,143 bytes)	9.91 KB	0644	✍️ ⬇️ 🗑️
📄 test_break.pyo (10,143 bytes)	9.91 KB	0644	✍️ ⬇️ 🗑️
📄 test_case.py (45,719 bytes)	44.65 KB	0644	✍️ ⬇️ 🗑️
📄 test_case.pyc (47,022 bytes)	45.92 KB	0644	✍️ ⬇️ 🗑️
📄 test_case.pyo (47,022 bytes)	45.92 KB	0644	✍️ ⬇️ 🗑️
📄 test_discovery.py (14,313 bytes)	13.98 KB	0644	✍️ ⬇️ 🗑️
📄 test_discovery.pyc (17,667 bytes)	17.25 KB	0644	✍️ ⬇️ 🗑️
📄 test_discovery.pyo (17,667 bytes)	17.25 KB	0644	✍️ ⬇️ 🗑️
📄 test_functiontestcase.py (5,547 bytes)	5.42 KB	0644	✍️ ⬇️ 🗑️
📄 test_functiontestcase.pyc (6,087 bytes)	5.94 KB	0644	✍️ ⬇️ 🗑️
📄 test_functiontestcase.pyo (6,087 bytes)	5.94 KB	0644	✍️ ⬇️ 🗑️
📄 test_loader.py (49,866 bytes)	48.7 KB	0644	✍️ ⬇️ 🗑️
📄 test_loader.pyc (49,820 bytes)	48.65 KB	0644	✍️ ⬇️ 🗑️
📄 test_loader.pyo (49,820 bytes)	48.65 KB	0644	✍️ ⬇️ 🗑️
📄 test_program.py (7,576 bytes)	7.4 KB	0644	✍️ ⬇️ 🗑️
📄 test_program.pyc (10,473 bytes)	10.23 KB	0644	✍️ ⬇️ 🗑️
📄 test_program.pyo (10,415 bytes)	10.17 KB	0644	✍️ ⬇️ 🗑️
📄 test_result.py (19,056 bytes)	18.61 KB	0644	✍️ ⬇️ 🗑️
📄 test_result.pyc (21,399 bytes)	20.9 KB	0644	✍️ ⬇️ 🗑️
📄 test_result.pyo (21,399 bytes)	20.9 KB	0644	✍️ ⬇️ 🗑️
📄 test_runner.py (8,609 bytes)	8.41 KB	0644	✍️ ⬇️ 🗑️
📄 test_runner.pyc (14,125 bytes)	13.79 KB	0644	✍️ ⬇️ 🗑️
📄 test_runner.pyo (14,125 bytes)	13.79 KB	0644	✍️ ⬇️ 🗑️
📄 test_setups.py (16,460 bytes)	16.07 KB	0644	✍️ ⬇️ 🗑️
📄 test_setups.pyc (29,173 bytes)	28.49 KB	0644	✍️ ⬇️ 🗑️
📄 test_setups.pyo (29,173 bytes)	28.49 KB	0644	✍️ ⬇️ 🗑️
📄 test_skipping.py (5,744 bytes)	5.61 KB	0644	✍️ ⬇️ 🗑️
📄 test_skipping.pyc (9,601 bytes)	9.38 KB	0644	✍️ ⬇️ 🗑️
📄 test_skipping.pyo (9,601 bytes)	9.38 KB	0644	✍️ ⬇️ 🗑️
📄 test_suite.py (12,082 bytes)	11.8 KB	0644	✍️ ⬇️ 🗑️
📄 test_suite.pyc (15,502 bytes)	15.14 KB	0644	✍️ ⬇️ 🗑️
📄 test_suite.pyo (15,502 bytes)	15.14 KB	0644	✍️ ⬇️ 🗑️

✍️ Editing: test_assertions.py

            File: /lib64/python2.7/unittest/test/test_assertions.py

            Size: 11.68 KB | 
            Last Modified: 2024-04-10 11:58:35        

import datetime

import unittest

class Test_Assertions(unittest.TestCase):
    def test_AlmostEqual(self):
        self.assertAlmostEqual(1.00000001, 1.0)
        self.assertNotAlmostEqual(1.0000001, 1.0)
        self.assertRaises(self.failureException,
                          self.assertAlmostEqual, 1.0000001, 1.0)
        self.assertRaises(self.failureException,
                          self.assertNotAlmostEqual, 1.00000001, 1.0)

self.assertAlmostEqual(1.1, 1.0, places=0)
        self.assertRaises(self.failureException,
                          self.assertAlmostEqual, 1.1, 1.0, places=1)

self.assertAlmostEqual(0, .1+.1j, places=0)
        self.assertNotAlmostEqual(0, .1+.1j, places=1)
        self.assertRaises(self.failureException,
                          self.assertAlmostEqual, 0, .1+.1j, places=1)
        self.assertRaises(self.failureException,
                          self.assertNotAlmostEqual, 0, .1+.1j, places=0)

self.assertAlmostEqual(float('inf'), float('inf'))
        self.assertRaises(self.failureException, self.assertNotAlmostEqual,
                          float('inf'), float('inf'))

def test_AmostEqualWithDelta(self):
        self.assertAlmostEqual(1.1, 1.0, delta=0.5)
        self.assertAlmostEqual(1.0, 1.1, delta=0.5)
        self.assertNotAlmostEqual(1.1, 1.0, delta=0.05)
        self.assertNotAlmostEqual(1.0, 1.1, delta=0.05)

self.assertAlmostEqual(1.0, 1.0, delta=0.5)
        self.assertRaises(self.failureException, self.assertNotAlmostEqual,
                          1.0, 1.0, delta=0.5)

self.assertRaises(self.failureException, self.assertAlmostEqual,
                          1.1, 1.0, delta=0.05)
        self.assertRaises(self.failureException, self.assertNotAlmostEqual,
                          1.1, 1.0, delta=0.5)

self.assertRaises(TypeError, self.assertAlmostEqual,
                          1.1, 1.0, places=2, delta=2)
        self.assertRaises(TypeError, self.assertNotAlmostEqual,
                          1.1, 1.0, places=2, delta=2)

first = datetime.datetime.now()
        second = first + datetime.timedelta(seconds=10)
        self.assertAlmostEqual(first, second,
                               delta=datetime.timedelta(seconds=20))
        self.assertNotAlmostEqual(first, second,
                                  delta=datetime.timedelta(seconds=5))

def test_assertRaises(self):
        def _raise(e):
            raise e
        self.assertRaises(KeyError, _raise, KeyError)
        self.assertRaises(KeyError, _raise, KeyError("key"))
        try:
            self.assertRaises(KeyError, lambda: None)
        except self.failureException as e:
            self.assertIn("KeyError not raised", e.args)
        else:
            self.fail("assertRaises() didn't fail")
        try:
            self.assertRaises(KeyError, _raise, ValueError)
        except ValueError:
            pass
        else:
            self.fail("assertRaises() didn't let exception pass through")
        with self.assertRaises(KeyError) as cm:
            try:
                raise KeyError
            except Exception, e:
                raise
        self.assertIs(cm.exception, e)

with self.assertRaises(KeyError):
            raise KeyError("key")
        try:
            with self.assertRaises(KeyError):
                pass
        except self.failureException as e:
            self.assertIn("KeyError not raised", e.args)
        else:
            self.fail("assertRaises() didn't fail")
        try:
            with self.assertRaises(KeyError):
                raise ValueError
        except ValueError:
            pass
        else:
            self.fail("assertRaises() didn't let exception pass through")

def testAssertNotRegexpMatches(self):
        self.assertNotRegexpMatches('Ala ma kota', r'r+')
        try:
            self.assertNotRegexpMatches('Ala ma kota', r'k.t', 'Message')
        except self.failureException, e:
            self.assertIn("'kot'", e.args[0])
            self.assertIn('Message', e.args[0])
        else:
            self.fail('assertNotRegexpMatches should have failed.')

class TestLongMessage(unittest.TestCase):
    """Test that the individual asserts honour longMessage.
    This actually tests all the message behaviour for
    asserts that use longMessage."""

def setUp(self):
        class TestableTestFalse(unittest.TestCase):
            longMessage = False
            failureException = self.failureException

def testTest(self):
                pass

class TestableTestTrue(unittest.TestCase):
            longMessage = True
            failureException = self.failureException

def testTest(self):
                pass

self.testableTrue = TestableTestTrue('testTest')
        self.testableFalse = TestableTestFalse('testTest')

def testDefault(self):
        self.assertFalse(unittest.TestCase.longMessage)

def test_formatMsg(self):
        self.assertEqual(self.testableFalse._formatMessage(None, "foo"), "foo")
        self.assertEqual(self.testableFalse._formatMessage("foo", "bar"), "foo")

self.assertEqual(self.testableTrue._formatMessage(None, "foo"), "foo")
        self.assertEqual(self.testableTrue._formatMessage("foo", "bar"), "bar : foo")

# This blows up if _formatMessage uses string concatenation
        self.testableTrue._formatMessage(object(), 'foo')

def test_formatMessage_unicode_error(self):
        one = ''.join(chr(i) for i in range(255))
        # this used to cause a UnicodeDecodeError constructing msg
        self.testableTrue._formatMessage(one, u'\uFFFD')

def assertMessages(self, methodName, args, errors):
        def getMethod(i):
            useTestableFalse  = i < 2
            if useTestableFalse:
                test = self.testableFalse
            else:
                test = self.testableTrue
            return getattr(test, methodName)

for i, expected_regexp in enumerate(errors):
            testMethod = getMethod(i)
            kwargs = {}
            withMsg = i % 2
            if withMsg:
                kwargs = {"msg": "oops"}

with self.assertRaisesRegexp(self.failureException,
                                         expected_regexp=expected_regexp):
                testMethod(*args, **kwargs)

def testAssertTrue(self):
        self.assertMessages('assertTrue', (False,),
                            ["^False is not true$", "^oops$", "^False is not true$",
                             "^False is not true : oops$"])

def testAssertFalse(self):
        self.assertMessages('assertFalse', (True,),
                            ["^True is not false$", "^oops$", "^True is not false$",
                             "^True is not false : oops$"])

def testNotEqual(self):
        self.assertMessages('assertNotEqual', (1, 1),
                            ["^1 == 1$", "^oops$", "^1 == 1$",
                             "^1 == 1 : oops$"])

def testAlmostEqual(self):
        self.assertMessages('assertAlmostEqual', (1, 2),
                            ["^1 != 2 within 7 places$", "^oops$",
                             "^1 != 2 within 7 places$", "^1 != 2 within 7 places : oops$"])

def testNotAlmostEqual(self):
        self.assertMessages('assertNotAlmostEqual', (1, 1),
                            ["^1 == 1 within 7 places$", "^oops$",
                             "^1 == 1 within 7 places$", "^1 == 1 within 7 places : oops$"])

def test_baseAssertEqual(self):
        self.assertMessages('_baseAssertEqual', (1, 2),
                            ["^1 != 2$", "^oops$", "^1 != 2$", "^1 != 2 : oops$"])

def testAssertSequenceEqual(self):
        # Error messages are multiline so not testing on full message
        # assertTupleEqual and assertListEqual delegate to this method
        self.assertMessages('assertSequenceEqual', ([], [None]),
                            ["\+ \[None\]$", "^oops$", r"\+ \[None\]$",
                             r"\+ \[None\] : oops$"])

def testAssertSetEqual(self):
        self.assertMessages('assertSetEqual', (set(), set([None])),
                            ["None$", "^oops$", "None$",
                             "None : oops$"])

def testAssertIn(self):
        self.assertMessages('assertIn', (None, []),
                            ['^None not found in \[\]$', "^oops$",
                             '^None not found in \[\]$',
                             '^None not found in \[\] : oops$'])

def testAssertNotIn(self):
        self.assertMessages('assertNotIn', (None, [None]),
                            ['^None unexpectedly found in \[None\]$', "^oops$",
                             '^None unexpectedly found in \[None\]$',
                             '^None unexpectedly found in \[None\] : oops$'])

def testAssertDictEqual(self):
        self.assertMessages('assertDictEqual', ({}, {'key': 'value'}),
                            [r"\+ \{'key': 'value'\}$", "^oops$",
                             "\+ \{'key': 'value'\}$",
                             "\+ \{'key': 'value'\} : oops$"])

def testAssertDictContainsSubset(self):
        self.assertMessages('assertDictContainsSubset', ({'key': 'value'}, {}),
                            ["^Missing: 'key'$", "^oops$",
                             "^Missing: 'key'$",
                             "^Missing: 'key' : oops$"])

def testAssertMultiLineEqual(self):
        self.assertMessages('assertMultiLineEqual', ("", "foo"),
                            [r"\+ foo$", "^oops$",
                             r"\+ foo$",
                             r"\+ foo : oops$"])

def testAssertLess(self):
        self.assertMessages('assertLess', (2, 1),
                            ["^2 not less than 1$", "^oops$",
                             "^2 not less than 1$", "^2 not less than 1 : oops$"])

def testAssertLessEqual(self):
        self.assertMessages('assertLessEqual', (2, 1),
                            ["^2 not less than or equal to 1$", "^oops$",
                             "^2 not less than or equal to 1$",
                             "^2 not less than or equal to 1 : oops$"])

def testAssertGreater(self):
        self.assertMessages('assertGreater', (1, 2),
                            ["^1 not greater than 2$", "^oops$",
                             "^1 not greater than 2$",
                             "^1 not greater than 2 : oops$"])

def testAssertGreaterEqual(self):
        self.assertMessages('assertGreaterEqual', (1, 2),
                            ["^1 not greater than or equal to 2$", "^oops$",
                             "^1 not greater than or equal to 2$",
                             "^1 not greater than or equal to 2 : oops$"])

def testAssertIsNone(self):
        self.assertMessages('assertIsNone', ('not None',),
                            ["^'not None' is not None$", "^oops$",
                             "^'not None' is not None$",
                             "^'not None' is not None : oops$"])

def testAssertIsNotNone(self):
        self.assertMessages('assertIsNotNone', (None,),
                            ["^unexpectedly None$", "^oops$",
                             "^unexpectedly None$",
                             "^unexpectedly None : oops$"])

def testAssertIs(self):
        self.assertMessages('assertIs', (None, 'foo'),
                            ["^None is not 'foo'$", "^oops$",
                             "^None is not 'foo'$",
                             "^None is not 'foo' : oops$"])

def testAssertIsNot(self):
        self.assertMessages('assertIsNot', (None, None),
                            ["^unexpectedly identical: None$", "^oops$",
                             "^unexpectedly identical: None$",
                             "^unexpectedly identical: None : oops$"])

if __name__ == '__main__':
    unittest.main()

↩️ Back

Zy Filemanager

📁 File Browser

📤 Upload Files

Single File

Multiple Files

ZIP Extract

➕ Create New

New Folder

New File

✍️ Editing: test_assertions.py

Backup Management