1 """Test correct treatment of hex/oct constants.

     2 

     3 This is complex because of changes due to PEP 237.

     4 """

     5 

     6 import sys

     7 platform_long_is_32_bits = sys.maxint == 2147483647

     8 

     9 import unittest

    10 from test import test_support

    11 

    12 import warnings

    13 warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning,

    14                         "<string>")

    15 

    16 class TextHexOct(unittest.TestCase):

    17 

    18     def test_hex_baseline(self):

    19         # Baseline tests

    20         self.assertEqual(0x0, 0)

    21         self.assertEqual(0x10, 16)

    22         if platform_long_is_32_bits:

    23             self.assertEqual(0x7fffffff, 2147483647)

    24         else:

    25             self.assertEqual(0x7fffffffffffffff, 9223372036854775807)

    26         # Ditto with a minus sign and parentheses

    27         self.assertEqual(-(0x0), 0)

    28         self.assertEqual(-(0x10), -16)

    29         if platform_long_is_32_bits:

    30             self.assertEqual(-(0x7fffffff), -2147483647)

    31         else:

    32             self.assertEqual(-(0x7fffffffffffffff), -9223372036854775807)

    33         # Ditto with a minus sign and NO parentheses

    34         self.assertEqual(-0x0, 0)

    35         self.assertEqual(-0x10, -16)

    36         if platform_long_is_32_bits:

    37             self.assertEqual(-0x7fffffff, -2147483647)

    38         else:

    39             self.assertEqual(-0x7fffffffffffffff, -9223372036854775807)

    40 

    41     def test_hex_unsigned(self):

    42         if platform_long_is_32_bits:

    43             # Positive constants

    44             self.assertEqual(0x80000000, 2147483648L)

    45             self.assertEqual(0xffffffff, 4294967295L)

    46             # Ditto with a minus sign and parentheses

    47             self.assertEqual(-(0x80000000), -2147483648L)

    48             self.assertEqual(-(0xffffffff), -4294967295L)

    49             # Ditto with a minus sign and NO parentheses

    50             # This failed in Python 2.2 through 2.2.2 and in 2.3a1

    51             self.assertEqual(-0x80000000, -2147483648L)

    52             self.assertEqual(-0xffffffff, -4294967295L)

    53         else:

    54             # Positive constants

    55             self.assertEqual(0x8000000000000000, 9223372036854775808L)

    56             self.assertEqual(0xffffffffffffffff, 18446744073709551615L)

    57             # Ditto with a minus sign and parentheses

    58             self.assertEqual(-(0x8000000000000000), -9223372036854775808L)

    59             self.assertEqual(-(0xffffffffffffffff), -18446744073709551615L)

    60             # Ditto with a minus sign and NO parentheses

    61             # This failed in Python 2.2 through 2.2.2 and in 2.3a1

    62             self.assertEqual(-0x8000000000000000, -9223372036854775808L)

    63             self.assertEqual(-0xffffffffffffffff, -18446744073709551615L)

    64 

    65     def test_oct_baseline(self):

    66         # Baseline tests

    67         self.assertEqual(00, 0)

    68         self.assertEqual(020, 16)

    69         if platform_long_is_32_bits:

    70             self.assertEqual(017777777777, 2147483647)

    71         else:

    72             self.assertEqual(0777777777777777777777, 9223372036854775807)

    73         # Ditto with a minus sign and parentheses

    74         self.assertEqual(-(00), 0)

    75         self.assertEqual(-(020), -16)

    76         if platform_long_is_32_bits:

    77             self.assertEqual(-(017777777777), -2147483647)

    78         else:

    79             self.assertEqual(-(0777777777777777777777), -9223372036854775807)

    80         # Ditto with a minus sign and NO parentheses

    81         self.assertEqual(-00, 0)

    82         self.assertEqual(-020, -16)

    83         if platform_long_is_32_bits:

    84             self.assertEqual(-017777777777, -2147483647)

    85         else:

    86             self.assertEqual(-0777777777777777777777, -9223372036854775807)

    87 

    88     def test_oct_unsigned(self):

    89         if platform_long_is_32_bits:

    90             # Positive constants

    91             self.assertEqual(020000000000, 2147483648L)

    92             self.assertEqual(037777777777, 4294967295L)

    93             # Ditto with a minus sign and parentheses

    94             self.assertEqual(-(020000000000), -2147483648L)

    95             self.assertEqual(-(037777777777), -4294967295L)

    96             # Ditto with a minus sign and NO parentheses

    97             # This failed in Python 2.2 through 2.2.2 and in 2.3a1

    98             self.assertEqual(-020000000000, -2147483648L)

    99             self.assertEqual(-037777777777, -4294967295L)

   100         else:

   101             # Positive constants

   102             self.assertEqual(01000000000000000000000, 9223372036854775808L)

   103             self.assertEqual(01777777777777777777777, 18446744073709551615L)

   104             # Ditto with a minus sign and parentheses

   105             self.assertEqual(-(01000000000000000000000), -9223372036854775808L)

   106             self.assertEqual(-(01777777777777777777777), -18446744073709551615L)

   107             # Ditto with a minus sign and NO parentheses

   108             # This failed in Python 2.2 through 2.2.2 and in 2.3a1

   109             self.assertEqual(-01000000000000000000000, -9223372036854775808L)

   110             self.assertEqual(-01777777777777777777777, -18446744073709551615L)

   111 

   112 def test_main():

   113     test_support.run_unittest(TextHexOct)

   114 

   115 if __name__ == "__main__":

   116     test_main()