EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Lib / test / test_xrange.py

# Python test set -- built-in functions\r
\r
import test.test_support, unittest\r
import sys\r
import pickle\r
import itertools\r
\r
import warnings\r
warnings.filterwarnings("ignore", "integer argument expected",\r
                        DeprecationWarning, "unittest")\r
\r
# pure Python implementations (3 args only), for comparison\r
def pyrange(start, stop, step):\r
    if (start - stop) // step < 0:\r
        # replace stop with next element in the sequence of integers\r
        # that are congruent to start modulo step.\r
        stop += (start - stop) % step\r
        while start != stop:\r
            yield start\r
            start += step\r
\r
def pyrange_reversed(start, stop, step):\r
    stop += (start - stop) % step\r
    return pyrange(stop - step, start - step, -step)\r
\r
\r
class XrangeTest(unittest.TestCase):\r
    def assert_iterators_equal(self, xs, ys, test_id, limit=None):\r
        # check that an iterator xs matches the expected results ys,\r
        # up to a given limit.\r
        if limit is not None:\r
            xs = itertools.islice(xs, limit)\r
            ys = itertools.islice(ys, limit)\r
        sentinel = object()\r
        pairs = itertools.izip_longest(xs, ys, fillvalue=sentinel)\r
        for i, (x, y) in enumerate(pairs):\r
            if x == y:\r
                continue\r
            elif x == sentinel:\r
                self.fail('{}: iterator ended unexpectedly '\r
                          'at position {}; expected {}'.format(test_id, i, y))\r
            elif y == sentinel:\r
                self.fail('{}: unexpected excess element {} at '\r
                          'position {}'.format(test_id, x, i))\r
            else:\r
                self.fail('{}: wrong element at position {};'\r
                          'expected {}, got {}'.format(test_id, i, y, x))\r
\r
    def test_xrange(self):\r
        self.assertEqual(list(xrange(3)), [0, 1, 2])\r
        self.assertEqual(list(xrange(1, 5)), [1, 2, 3, 4])\r
        self.assertEqual(list(xrange(0)), [])\r
        self.assertEqual(list(xrange(-3)), [])\r
        self.assertEqual(list(xrange(1, 10, 3)), [1, 4, 7])\r
        self.assertEqual(list(xrange(5, -5, -3)), [5, 2, -1, -4])\r
\r
        a = 10\r
        b = 100\r
        c = 50\r
\r
        self.assertEqual(list(xrange(a, a+2)), [a, a+1])\r
        self.assertEqual(list(xrange(a+2, a, -1L)), [a+2, a+1])\r
        self.assertEqual(list(xrange(a+4, a, -2)), [a+4, a+2])\r
\r
        seq = list(xrange(a, b, c))\r
        self.assertIn(a, seq)\r
        self.assertNotIn(b, seq)\r
        self.assertEqual(len(seq), 2)\r
\r
        seq = list(xrange(b, a, -c))\r
        self.assertIn(b, seq)\r
        self.assertNotIn(a, seq)\r
        self.assertEqual(len(seq), 2)\r
\r
        seq = list(xrange(-a, -b, -c))\r
        self.assertIn(-a, seq)\r
        self.assertNotIn(-b, seq)\r
        self.assertEqual(len(seq), 2)\r
\r
        self.assertRaises(TypeError, xrange)\r
        self.assertRaises(TypeError, xrange, 1, 2, 3, 4)\r
        self.assertRaises(ValueError, xrange, 1, 2, 0)\r
\r
        self.assertRaises(OverflowError, xrange, 10**100, 10**101, 10**101)\r
\r
        self.assertRaises(TypeError, xrange, 0, "spam")\r
        self.assertRaises(TypeError, xrange, 0, 42, "spam")\r
\r
        self.assertEqual(len(xrange(0, sys.maxint, sys.maxint-1)), 2)\r
\r
        self.assertRaises(OverflowError, xrange, -sys.maxint, sys.maxint)\r
        self.assertRaises(OverflowError, xrange, 0, 2*sys.maxint)\r
\r
        r = xrange(-sys.maxint, sys.maxint, 2)\r
        self.assertEqual(len(r), sys.maxint)\r
        self.assertRaises(OverflowError, xrange, -sys.maxint-1, sys.maxint, 2)\r
\r
    def test_pickling(self):\r
        testcases = [(13,), (0, 11), (-22, 10), (20, 3, -1),\r
                     (13, 21, 3), (-2, 2, 2)]\r
        for proto in range(pickle.HIGHEST_PROTOCOL + 1):\r
            for t in testcases:\r
                r = xrange(*t)\r
                self.assertEqual(list(pickle.loads(pickle.dumps(r, proto))),\r
                                 list(r))\r
\r
    def test_range_iterators(self):\r
        # see issue 7298\r
        limits = [base + jiggle\r
                  for M in (2**32, 2**64)\r
                  for base in (-M, -M//2, 0, M//2, M)\r
                  for jiggle in (-2, -1, 0, 1, 2)]\r
        test_ranges = [(start, end, step)\r
                       for start in limits\r
                       for end in limits\r
                       for step in (-2**63, -2**31, -2, -1, 1, 2)]\r
\r
        for start, end, step in test_ranges:\r
            try:\r
                iter1 = xrange(start, end, step)\r
            except OverflowError:\r
                pass\r
            else:\r
                iter2 = pyrange(start, end, step)\r
                test_id = "xrange({}, {}, {})".format(start, end, step)\r
                # check first 100 entries\r
                self.assert_iterators_equal(iter1, iter2, test_id, limit=100)\r
\r
            try:\r
                iter1 = reversed(xrange(start, end, step))\r
            except OverflowError:\r
                pass\r
            else:\r
                iter2 = pyrange_reversed(start, end, step)\r
                test_id = "reversed(xrange({}, {}, {}))".format(start, end, step)\r
                self.assert_iterators_equal(iter1, iter2, test_id, limit=100)\r
\r
\r
def test_main():\r
    test.test_support.run_unittest(XrangeTest)\r
\r
if __name__ == "__main__":\r
    test_main()\r