Skip to content

Commit 9ff19b5

Browse files
ericvsmithericvsmith
committed
Finished backporting PEP 3127, Integer Literal Support and Syntax.
Added 0b and 0o literals to tokenizer. Modified PyOS_strtoul to support 0b and 0o inputs. Modified PyLong_FromString to support guessing 0b and 0o inputs. Renamed test_hexoct.py to test_int_literal.py and added binary tests. Added upper and lower case 0b, 0O, and 0X tests to test_int_literal.py
1 parent 7cfbf0c commit 9ff19b5

7 files changed

Lines changed: 336 additions & 125 deletions

File tree

‎Lib/test/test_builtin.py‎

Lines changed: 45 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -853,6 +853,12 @@ def test_int(self):
853853
self.assertRaises(ValueError, int, "0x", 16)
854854
self.assertRaises(ValueError, int, "0x", 0)
855855

856+
self.assertRaises(ValueError, int, "0o", 8)
857+
self.assertRaises(ValueError, int, "0o", 0)
858+
859+
self.assertRaises(ValueError, int, "0b", 2)
860+
self.assertRaises(ValueError, int, "0b", 0)
861+
856862

857863
# SF bug 1334662: int(string, base) wrong answers
858864
# Various representations of 2**32 evaluated to 0
@@ -894,6 +900,45 @@ def test_int(self):
894900
self.assertEqual(int('2br45qb', 35), 4294967296L)
895901
self.assertEqual(int('1z141z4', 36), 4294967296L)
896902

903+
# tests with base 0
904+
# this fails on 3.0, but in 2.x the old octal syntax is allowed
905+
self.assertEqual(int(' 0123 ', 0), 83)
906+
self.assertEqual(int(' 0123 ', 0), 83)
907+
self.assertEqual(int('000', 0), 0)
908+
self.assertEqual(int('0o123', 0), 83)
909+
self.assertEqual(int('0x123', 0), 291)
910+
self.assertEqual(int('0b100', 0), 4)
911+
self.assertEqual(int(' 0O123 ', 0), 83)
912+
self.assertEqual(int(' 0X123 ', 0), 291)
913+
self.assertEqual(int(' 0B100 ', 0), 4)
914+
915+
# without base still base 10
916+
self.assertEqual(int('0123'), 123)
917+
self.assertEqual(int('0123', 10), 123)
918+
919+
# tests with prefix and base != 0
920+
self.assertEqual(int('0x123', 16), 291)
921+
self.assertEqual(int('0o123', 8), 83)
922+
self.assertEqual(int('0b100', 2), 4)
923+
self.assertEqual(int('0X123', 16), 291)
924+
self.assertEqual(int('0O123', 8), 83)
925+
self.assertEqual(int('0B100', 2), 4)
926+
927+
# the code has special checks for the first character after the
928+
# type prefix
929+
self.assertRaises(ValueError, int, '0b2', 2)
930+
self.assertRaises(ValueError, int, '0b02', 2)
931+
self.assertRaises(ValueError, int, '0B2', 2)
932+
self.assertRaises(ValueError, int, '0B02', 2)
933+
self.assertRaises(ValueError, int, '0o8', 8)
934+
self.assertRaises(ValueError, int, '0o08', 8)
935+
self.assertRaises(ValueError, int, '0O8', 8)
936+
self.assertRaises(ValueError, int, '0O08', 8)
937+
self.assertRaises(ValueError, int, '0xg', 16)
938+
self.assertRaises(ValueError, int, '0x0g', 16)
939+
self.assertRaises(ValueError, int, '0Xg', 16)
940+
self.assertRaises(ValueError, int, '0X0g', 16)
941+
897942
# SF bug 1334662: int(string, base) wrong answers
898943
# Checks for proper evaluation of 2**32 + 1
899944
self.assertEqual(int('100000000000000000000000000000001', 2), 4294967297L)

‎Lib/test/test_compile.py‎

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -180,7 +180,9 @@ def test_leading_newlines(self):
180180

181181
def test_literals_with_leading_zeroes(self):
182182
for arg in ["077787", "0xj", "0x.", "0e", "090000000000000",
183-
"080000000000000", "000000000000009", "000000000000008"]:
183+
"080000000000000", "000000000000009", "000000000000008",
184+
"0b42", "0BADCAFE", "0o123456789", "0b1.1", "0o4.2",
185+
"0b101j2", "0o153j2", "0b100e1", "0o777e1"]:
184186
self.assertRaises(SyntaxError, eval, arg)
185187

186188
self.assertEqual(eval("0777"), 511)
@@ -208,6 +210,10 @@ def test_literals_with_leading_zeroes(self):
208210
self.assertEqual(eval("000000000000007"), 7)
209211
self.assertEqual(eval("000000000000008."), 8.)
210212
self.assertEqual(eval("000000000000009."), 9.)
213+
self.assertEqual(eval("0b101010"), 42)
214+
self.assertEqual(eval("-0b000000000010"), -2)
215+
self.assertEqual(eval("0o777"), 511)
216+
self.assertEqual(eval("-0o0000010"), -8)
211217

212218
def test_unary_minus(self):
213219
# Verify treatment of unary minus on negative numbers SF bug #660455

‎Lib/test/test_hexoct.py‎

Lines changed: 0 additions & 116 deletions
This file was deleted.

‎Lib/test/test_int_literal.py‎

Lines changed: 191 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,191 @@
1+
"""Test correct treatment of hex/oct constants.
2+
3+
This is complex because of changes due to PEP 237.
4+
"""
5+
6+
import unittest
7+
from test import test_support
8+
9+
import warnings
10+
warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning,
11+
"<string>")
12+
13+
class TextHexOctBin(unittest.TestCase):
14+
15+
def test_hex_baseline(self):
16+
# A few upper/lowercase tests
17+
self.assertEqual(0x0, 0X0)
18+
self.assertEqual(0x1, 0X1)
19+
self.assertEqual(0x123456789abcdef, 0X123456789abcdef)
20+
# Baseline tests
21+
self.assertEqual(0x0, 0)
22+
self.assertEqual(0x10, 16)
23+
self.assertEqual(0x7fffffff, 2147483647)
24+
self.assertEqual(0x7fffffffffffffff, 9223372036854775807)
25+
# Ditto with a minus sign and parentheses
26+
self.assertEqual(-(0x0), 0)
27+
self.assertEqual(-(0x10), -16)
28+
self.assertEqual(-(0x7fffffff), -2147483647)
29+
self.assertEqual(-(0x7fffffffffffffff), -9223372036854775807)
30+
# Ditto with a minus sign and NO parentheses
31+
self.assertEqual(-0x0, 0)
32+
self.assertEqual(-0x10, -16)
33+
self.assertEqual(-0x7fffffff, -2147483647)
34+
self.assertEqual(-0x7fffffffffffffff, -9223372036854775807)
35+
36+
def test_hex_unsigned(self):
37+
# Positive constants
38+
self.assertEqual(0x80000000, 2147483648L)
39+
self.assertEqual(0xffffffff, 4294967295L)
40+
# Ditto with a minus sign and parentheses
41+
self.assertEqual(-(0x80000000), -2147483648L)
42+
self.assertEqual(-(0xffffffff), -4294967295L)
43+
# Ditto with a minus sign and NO parentheses
44+
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
45+
self.assertEqual(-0x80000000, -2147483648L)
46+
self.assertEqual(-0xffffffff, -4294967295L)
47+
48+
# Positive constants
49+
self.assertEqual(0x8000000000000000, 9223372036854775808L)
50+
self.assertEqual(0xffffffffffffffff, 18446744073709551615L)
51+
# Ditto with a minus sign and parentheses
52+
self.assertEqual(-(0x8000000000000000), -9223372036854775808L)
53+
self.assertEqual(-(0xffffffffffffffff), -18446744073709551615L)
54+
# Ditto with a minus sign and NO parentheses
55+
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
56+
self.assertEqual(-0x8000000000000000, -9223372036854775808L)
57+
self.assertEqual(-0xffffffffffffffff, -18446744073709551615L)
58+
59+
def test_oct_baseline(self):
60+
# Baseline tests
61+
self.assertEqual(00, 0)
62+
self.assertEqual(020, 16)
63+
self.assertEqual(017777777777, 2147483647)
64+
self.assertEqual(0777777777777777777777, 9223372036854775807)
65+
# Ditto with a minus sign and parentheses
66+
self.assertEqual(-(00), 0)
67+
self.assertEqual(-(020), -16)
68+
self.assertEqual(-(017777777777), -2147483647)
69+
self.assertEqual(-(0777777777777777777777), -9223372036854775807)
70+
# Ditto with a minus sign and NO parentheses
71+
self.assertEqual(-00, 0)
72+
self.assertEqual(-020, -16)
73+
self.assertEqual(-017777777777, -2147483647)
74+
self.assertEqual(-0777777777777777777777, -9223372036854775807)
75+
76+
def test_oct_baseline_new(self):
77+
# A few upper/lowercase tests
78+
self.assertEqual(0o0, 0O0)
79+
self.assertEqual(0o1, 0O1)
80+
self.assertEqual(0o1234567, 0O1234567)
81+
# Baseline tests
82+
self.assertEqual(0o0, 0)
83+
self.assertEqual(0o20, 16)
84+
self.assertEqual(0o17777777777, 2147483647)
85+
self.assertEqual(0o777777777777777777777, 9223372036854775807)
86+
# Ditto with a minus sign and parentheses
87+
self.assertEqual(-(0o0), 0)
88+
self.assertEqual(-(0o20), -16)
89+
self.assertEqual(-(0o17777777777), -2147483647)
90+
self.assertEqual(-(0o777777777777777777777), -9223372036854775807)
91+
# Ditto with a minus sign and NO parentheses
92+
self.assertEqual(-0o0, 0)
93+
self.assertEqual(-0o20, -16)
94+
self.assertEqual(-0o17777777777, -2147483647)
95+
self.assertEqual(-0o777777777777777777777, -9223372036854775807)
96+
97+
def test_oct_unsigned(self):
98+
# Positive constants
99+
self.assertEqual(020000000000, 2147483648L)
100+
self.assertEqual(037777777777, 4294967295L)
101+
# Ditto with a minus sign and parentheses
102+
self.assertEqual(-(020000000000), -2147483648L)
103+
self.assertEqual(-(037777777777), -4294967295L)
104+
# Ditto with a minus sign and NO parentheses
105+
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
106+
self.assertEqual(-020000000000, -2147483648L)
107+
self.assertEqual(-037777777777, -4294967295L)
108+
109+
# Positive constants
110+
self.assertEqual(01000000000000000000000, 9223372036854775808L)
111+
self.assertEqual(01777777777777777777777, 18446744073709551615L)
112+
# Ditto with a minus sign and parentheses
113+
self.assertEqual(-(01000000000000000000000), -9223372036854775808L)
114+
self.assertEqual(-(01777777777777777777777), -18446744073709551615L)
115+
# Ditto with a minus sign and NO parentheses
116+
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
117+
self.assertEqual(-01000000000000000000000, -9223372036854775808L)
118+
self.assertEqual(-01777777777777777777777, -18446744073709551615L)
119+
120+
def test_oct_unsigned_new(self):
121+
# Positive constants
122+
self.assertEqual(0o20000000000, 2147483648L)
123+
self.assertEqual(0o37777777777, 4294967295L)
124+
# Ditto with a minus sign and parentheses
125+
self.assertEqual(-(0o20000000000), -2147483648L)
126+
self.assertEqual(-(0o37777777777), -4294967295L)
127+
# Ditto with a minus sign and NO parentheses
128+
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
129+
self.assertEqual(-0o20000000000, -2147483648L)
130+
self.assertEqual(-0o37777777777, -4294967295L)
131+
132+
# Positive constants
133+
self.assertEqual(0o1000000000000000000000, 9223372036854775808L)
134+
self.assertEqual(0o1777777777777777777777, 18446744073709551615L)
135+
# Ditto with a minus sign and parentheses
136+
self.assertEqual(-(0o1000000000000000000000), -9223372036854775808L)
137+
self.assertEqual(-(0o1777777777777777777777), -18446744073709551615L)
138+
# Ditto with a minus sign and NO parentheses
139+
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
140+
self.assertEqual(-0o1000000000000000000000, -9223372036854775808L)
141+
self.assertEqual(-0o1777777777777777777777, -18446744073709551615L)
142+
143+
def test_bin_baseline(self):
144+
# A few upper/lowercase tests
145+
self.assertEqual(0b0, 0B0)
146+
self.assertEqual(0b1, 0B1)
147+
self.assertEqual(0b10101010101, 0B10101010101)
148+
# Baseline tests
149+
self.assertEqual(0b0, 0)
150+
self.assertEqual(0b10000, 16)
151+
self.assertEqual(0b1111111111111111111111111111111, 2147483647)
152+
self.assertEqual(0b111111111111111111111111111111111111111111111111111111111111111, 9223372036854775807)
153+
# Ditto with a minus sign and parentheses
154+
self.assertEqual(-(0b0), 0)
155+
self.assertEqual(-(0b10000), -16)
156+
self.assertEqual(-(0b1111111111111111111111111111111), -2147483647)
157+
self.assertEqual(-(0b111111111111111111111111111111111111111111111111111111111111111), -9223372036854775807)
158+
# Ditto with a minus sign and NO parentheses
159+
self.assertEqual(-0b0, 0)
160+
self.assertEqual(-0b10000, -16)
161+
self.assertEqual(-0b1111111111111111111111111111111, -2147483647)
162+
self.assertEqual(-0b111111111111111111111111111111111111111111111111111111111111111, -9223372036854775807)
163+
164+
def test_bin_unsigned(self):
165+
# Positive constants
166+
self.assertEqual(0b10000000000000000000000000000000, 2147483648L)
167+
self.assertEqual(0b11111111111111111111111111111111, 4294967295L)
168+
# Ditto with a minus sign and parentheses
169+
self.assertEqual(-(0b10000000000000000000000000000000), -2147483648L)
170+
self.assertEqual(-(0b11111111111111111111111111111111), -4294967295L)
171+
# Ditto with a minus sign and NO parentheses
172+
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
173+
self.assertEqual(-0b10000000000000000000000000000000, -2147483648L)
174+
self.assertEqual(-0b11111111111111111111111111111111, -4294967295L)
175+
176+
# Positive constants
177+
self.assertEqual(0b1000000000000000000000000000000000000000000000000000000000000000, 9223372036854775808L)
178+
self.assertEqual(0b1111111111111111111111111111111111111111111111111111111111111111, 18446744073709551615L)
179+
# Ditto with a minus sign and parentheses
180+
self.assertEqual(-(0b1000000000000000000000000000000000000000000000000000000000000000), -9223372036854775808L)
181+
self.assertEqual(-(0b1111111111111111111111111111111111111111111111111111111111111111), -18446744073709551615L)
182+
# Ditto with a minus sign and NO parentheses
183+
# This failed in Python 2.2 through 2.2.2 and in 2.3a1
184+
self.assertEqual(-0b1000000000000000000000000000000000000000000000000000000000000000, -9223372036854775808L)
185+
self.assertEqual(-0b1111111111111111111111111111111111111111111111111111111111111111, -18446744073709551615L)
186+
187+
def test_main():
188+
test_support.run_unittest(TextHexOctBin)
189+
190+
if __name__ == "__main__":
191+
test_main()

0 commit comments

Comments
 (0)