[OpenSPARC-T2-DV] / tools / src / nas,5.n2.os.2 / lib / python / lib / python2.4 / test / test_compile.py

import unittest
import warnings
import sys
from test import test_support

class TestSpecifics(unittest.TestCase):

    def test_debug_assignment(self):
        # catch assignments to __debug__
        self.assertRaises(SyntaxError, compile, '__debug__ = 1', '?', 'single')
        import __builtin__
        prev = __builtin__.__debug__
        setattr(__builtin__, '__debug__', 'sure')
        setattr(__builtin__, '__debug__', prev)

    def test_argument_handling(self):
        # detect duplicate positional and keyword arguments
        self.assertRaises(SyntaxError, eval, 'lambda a,a:0')
        self.assertRaises(SyntaxError, eval, 'lambda a,a=1:0')
        self.assertRaises(SyntaxError, eval, 'lambda a=1,a=1:0')
        try:
            exec 'def f(a, a): pass'
            self.fail("duplicate arguments")
        except SyntaxError:
            pass
        try:
            exec 'def f(a = 0, a = 1): pass'
            self.fail("duplicate keyword arguments")
        except SyntaxError:
            pass
        try:
            exec 'def f(a): global a; a = 1'
            self.fail("variable is global and local")
        except SyntaxError:
            pass

    def test_syntax_error(self):
        self.assertRaises(SyntaxError, compile, "1+*3", "filename", "exec")

    def test_duplicate_global_local(self):
        try:
            exec 'def f(a): global a; a = 1'
            self.fail("variable is global and local")
        except SyntaxError:
            pass

    def test_exec_with_general_mapping_for_locals(self):

        class M:
            "Test mapping interface versus possible calls from eval()."
            def __getitem__(self, key):
                if key == 'a':
                    return 12
                raise KeyError
            def __setitem__(self, key, value):
                self.results = (key, value)
            def keys(self):
                return list('xyz')

        m = M()
        g = globals()
        exec 'z = a' in g, m
        self.assertEqual(m.results, ('z', 12))
        try:
            exec 'z = b' in g, m
        except NameError:
            pass
        else:
            self.fail('Did not detect a KeyError')
        exec 'z = dir()' in g, m
        self.assertEqual(m.results, ('z', list('xyz')))
        exec 'z = globals()' in g, m
        self.assertEqual(m.results, ('z', g))
        exec 'z = locals()' in g, m
        self.assertEqual(m.results, ('z', m))
        try:
            exec 'z = b' in m
        except TypeError:
            pass
        else:
            self.fail('Did not validate globals as a real dict')

        class A:
            "Non-mapping"
            pass
        m = A()
        try:
            exec 'z = a' in g, m
        except TypeError:
            pass
        else:
            self.fail('Did not validate locals as a mapping')

        # Verify that dict subclasses work as well
        class D(dict):
            def __getitem__(self, key):
                if key == 'a':
                    return 12
                return dict.__getitem__(self, key)
        d = D()
        exec 'z = a' in g, d
        self.assertEqual(d['z'], 12)

    def test_complex_args(self):

        def comp_args((a, b)):
            return a,b
        self.assertEqual(comp_args((1, 2)), (1, 2))

        def comp_args((a, b)=(3, 4)):
            return a, b
        self.assertEqual(comp_args((1, 2)), (1, 2))
        self.assertEqual(comp_args(), (3, 4))

        def comp_args(a, (b, c)):
            return a, b, c
        self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))

        def comp_args(a=2, (b, c)=(3, 4)):
            return a, b, c
        self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
        self.assertEqual(comp_args(), (2, 3, 4))

    def test_argument_order(self):
        try:
            exec 'def f(a=1, (b, c)): pass'
            self.fail("non-default args after default")
        except SyntaxError:
            pass

    def test_float_literals(self):
        # testing bad float literals
        self.assertRaises(SyntaxError, eval, "2e")
        self.assertRaises(SyntaxError, eval, "2.0e+")
        self.assertRaises(SyntaxError, eval, "1e-")
        self.assertRaises(SyntaxError, eval, "3-4e/21")

    def test_indentation(self):
        # testing compile() of indented block w/o trailing newline"
        s = """
if 1:
    if 2:
        pass"""
        compile(s, "<string>", "exec")

    def test_literals_with_leading_zeroes(self):
        for arg in ["077787", "0xj", "0x.", "0e",  "090000000000000",
                    "080000000000000", "000000000000009", "000000000000008"]:
            self.assertRaises(SyntaxError, eval, arg)

        self.assertEqual(eval("0777"), 511)
        self.assertEqual(eval("0777L"), 511)
        self.assertEqual(eval("000777"), 511)
        self.assertEqual(eval("0xff"), 255)
        self.assertEqual(eval("0xffL"), 255)
        self.assertEqual(eval("0XfF"), 255)
        self.assertEqual(eval("0777."), 777)
        self.assertEqual(eval("0777.0"), 777)
        self.assertEqual(eval("000000000000000000000000000000000000000000000000000777e0"), 777)
        self.assertEqual(eval("0777e1"), 7770)
        self.assertEqual(eval("0e0"), 0)
        self.assertEqual(eval("0000E-012"), 0)
        self.assertEqual(eval("09.5"), 9.5)
        self.assertEqual(eval("0777j"), 777j)
        self.assertEqual(eval("00j"), 0j)
        self.assertEqual(eval("00.0"), 0)
        self.assertEqual(eval("0e3"), 0)
        self.assertEqual(eval("090000000000000."), 90000000000000.)
        self.assertEqual(eval("090000000000000.0000000000000000000000"), 90000000000000.)
        self.assertEqual(eval("090000000000000e0"), 90000000000000.)
        self.assertEqual(eval("090000000000000e-0"), 90000000000000.)
        self.assertEqual(eval("090000000000000j"), 90000000000000j)
        self.assertEqual(eval("000000000000007"), 7)
        self.assertEqual(eval("000000000000008."), 8.)
        self.assertEqual(eval("000000000000009."), 9.)

    def test_unary_minus(self):
        # Verify treatment of unary minus on negative numbers SF bug #660455
        if sys.maxint == 2147483647:
            # 32-bit machine
            all_one_bits = '0xffffffff'
            self.assertEqual(eval(all_one_bits), 4294967295L)
            self.assertEqual(eval("-" + all_one_bits), -4294967295L)
        elif sys.maxint == 9223372036854775807:
            # 64-bit machine
            all_one_bits = '0xffffffffffffffff'
            self.assertEqual(eval(all_one_bits), 18446744073709551615L)
            self.assertEqual(eval("-" + all_one_bits), -18446744073709551615L)
        else:
            self.fail("How many bits *does* this machine have???")

    def test_sequence_unpacking_error(self):
        # Verify sequence packing/unpacking with "or".  SF bug #757818
        i,j = (1, -1) or (-1, 1)
        self.assertEqual(i, 1)
        self.assertEqual(j, -1)

    def test_none_assignment(self):
        stmts = [
            'None = 0',
            'None += 0',
            '__builtins__.None = 0',
            'def None(): pass',
            'class None: pass',
            '(a, None) = 0, 0',
            'for None in range(10): pass',
            'def f(None): pass',
        ]
        for stmt in stmts:
            stmt += "\n"
            self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'single')
            self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')

    def test_import(self):
        succeed = [
            'import sys',
            'import os, sys',
            'from __future__ import nested_scopes, generators',
            'from __future__ import (nested_scopes,\ngenerators)',
            'from __future__ import (nested_scopes,\ngenerators,)',
            'from sys import stdin, stderr, stdout',
            'from sys import (stdin, stderr,\nstdout)',
            'from sys import (stdin, stderr,\nstdout,)',
            'from sys import (stdin\n, stderr, stdout)',
            'from sys import (stdin\n, stderr, stdout,)',
            'from sys import stdin as si, stdout as so, stderr as se',
            'from sys import (stdin as si, stdout as so, stderr as se)',
            'from sys import (stdin as si, stdout as so, stderr as se,)',
            ]
        fail = [
            'import (os, sys)',
            'import (os), (sys)',
            'import ((os), (sys))',
            'import (sys',
            'import sys)',
            'import (os,)',
            'from (sys) import stdin',
            'from __future__ import (nested_scopes',
            'from __future__ import nested_scopes)',
            'from __future__ import nested_scopes,\ngenerators',
            'from sys import (stdin',
            'from sys import stdin)',
            'from sys import stdin, stdout,\nstderr',
            'from sys import stdin si',
            'from sys import stdin,'
            'from sys import (*)',
            'from sys import (stdin,, stdout, stderr)',
            'from sys import (stdin, stdout),',
            ]
        for stmt in succeed:
            compile(stmt, 'tmp', 'exec')
        for stmt in fail:
            self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')

    def test_for_distinct_code_objects(self):
        # SF bug 1048870
        def f():
            f1 = lambda x=1: x
            f2 = lambda x=2: x
            return f1, f2
        f1, f2 = f()
        self.assertNotEqual(id(f1.func_code), id(f2.func_code))

def test_main():
    test_support.run_unittest(TestSpecifics)

if __name__ == "__main__":
    test_main()
Commit	Line	Data
86530b38 AT	1	import unittest
	2	import warnings
	3	import sys
	4	from test import test_support
	5
	6	class TestSpecifics(unittest.TestCase):
	7
	8	def test_debug_assignment(self):
	9	# catch assignments to __debug__
	10	self.assertRaises(SyntaxError, compile, '__debug__ = 1', '?', 'single')
	11	import __builtin__
	12	prev = __builtin__.__debug__
	13	setattr(__builtin__, '__debug__', 'sure')
	14	setattr(__builtin__, '__debug__', prev)
	15
	16	def test_argument_handling(self):
	17	# detect duplicate positional and keyword arguments
	18	self.assertRaises(SyntaxError, eval, 'lambda a,a:0')
	19	self.assertRaises(SyntaxError, eval, 'lambda a,a=1:0')
	20	self.assertRaises(SyntaxError, eval, 'lambda a=1,a=1:0')
	21	try:
	22	exec 'def f(a, a): pass'
	23	self.fail("duplicate arguments")
	24	except SyntaxError:
	25	pass
	26	try:
	27	exec 'def f(a = 0, a = 1): pass'
	28	self.fail("duplicate keyword arguments")
	29	except SyntaxError:
	30	pass
	31	try:
	32	exec 'def f(a): global a; a = 1'
	33	self.fail("variable is global and local")
	34	except SyntaxError:
	35	pass
	36
	37	def test_syntax_error(self):
	38	self.assertRaises(SyntaxError, compile, "1+*3", "filename", "exec")
	39
	40	def test_duplicate_global_local(self):
	41	try:
	42	exec 'def f(a): global a; a = 1'
	43	self.fail("variable is global and local")
	44	except SyntaxError:
	45	pass
	46
	47	def test_exec_with_general_mapping_for_locals(self):
	48
	49	class M:
	50	"Test mapping interface versus possible calls from eval()."
	51	def __getitem__(self, key):
	52	if key == 'a':
	53	return 12
	54	raise KeyError
	55	def __setitem__(self, key, value):
	56	self.results = (key, value)
	57	def keys(self):
	58	return list('xyz')
	59
	60	m = M()
	61	g = globals()
	62	exec 'z = a' in g, m
	63	self.assertEqual(m.results, ('z', 12))
	64	try:
65	exec 'z = b' in g, m
66	except NameError:
67	pass
68	else:
69	self.fail('Did not detect a KeyError')
70	exec 'z = dir()' in g, m
71	self.assertEqual(m.results, ('z', list('xyz')))
72	exec 'z = globals()' in g, m
73	self.assertEqual(m.results, ('z', g))
74	exec 'z = locals()' in g, m
75	self.assertEqual(m.results, ('z', m))
76	try:
77	exec 'z = b' in m
78	except TypeError:
79	pass
80	else:
81	self.fail('Did not validate globals as a real dict')
82
83	class A:
84	"Non-mapping"
85	pass
86	m = A()
87	try:
88	exec 'z = a' in g, m
89	except TypeError:
90	pass
91	else:
92	self.fail('Did not validate locals as a mapping')
93
94	# Verify that dict subclasses work as well
95	class D(dict):
96	def __getitem__(self, key):
97	if key == 'a':
98	return 12
99	return dict.__getitem__(self, key)
100	d = D()
101	exec 'z = a' in g, d
102	self.assertEqual(d['z'], 12)
103
104	def test_complex_args(self):
105
106	def comp_args((a, b)):
107	return a,b
108	self.assertEqual(comp_args((1, 2)), (1, 2))
109
110	def comp_args((a, b)=(3, 4)):
111	return a, b
112	self.assertEqual(comp_args((1, 2)), (1, 2))
113	self.assertEqual(comp_args(), (3, 4))
114
115	def comp_args(a, (b, c)):
116	return a, b, c
117	self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
118
119	def comp_args(a=2, (b, c)=(3, 4)):
120	return a, b, c
121	self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3))
122	self.assertEqual(comp_args(), (2, 3, 4))
123
124	def test_argument_order(self):
125	try:
126	exec 'def f(a=1, (b, c)): pass'
127	self.fail("non-default args after default")
128	except SyntaxError:
129	pass
130
131	def test_float_literals(self):
132	# testing bad float literals
133	self.assertRaises(SyntaxError, eval, "2e")
134	self.assertRaises(SyntaxError, eval, "2.0e+")
135	self.assertRaises(SyntaxError, eval, "1e-")
136	self.assertRaises(SyntaxError, eval, "3-4e/21")
137
138	def test_indentation(self):
139	# testing compile() of indented block w/o trailing newline"
140	s = """
141	if 1:
142	if 2:
143	pass"""
144	compile(s, "<string>", "exec")
145
146	def test_literals_with_leading_zeroes(self):
147	for arg in ["077787", "0xj", "0x.", "0e", "090000000000000",
148	"080000000000000", "000000000000009", "000000000000008"]:
149	self.assertRaises(SyntaxError, eval, arg)
150
151	self.assertEqual(eval("0777"), 511)
152	self.assertEqual(eval("0777L"), 511)
153	self.assertEqual(eval("000777"), 511)
154	self.assertEqual(eval("0xff"), 255)
155	self.assertEqual(eval("0xffL"), 255)
156	self.assertEqual(eval("0XfF"), 255)
157	self.assertEqual(eval("0777."), 777)
158	self.assertEqual(eval("0777.0"), 777)
159	self.assertEqual(eval("000000000000000000000000000000000000000000000000000777e0"), 777)
160	self.assertEqual(eval("0777e1"), 7770)
161	self.assertEqual(eval("0e0"), 0)
162	self.assertEqual(eval("0000E-012"), 0)
163	self.assertEqual(eval("09.5"), 9.5)
164	self.assertEqual(eval("0777j"), 777j)
165	self.assertEqual(eval("00j"), 0j)
166	self.assertEqual(eval("00.0"), 0)
167	self.assertEqual(eval("0e3"), 0)
168	self.assertEqual(eval("090000000000000."), 90000000000000.)
169	self.assertEqual(eval("090000000000000.0000000000000000000000"), 90000000000000.)
170	self.assertEqual(eval("090000000000000e0"), 90000000000000.)
171	self.assertEqual(eval("090000000000000e-0"), 90000000000000.)
172	self.assertEqual(eval("090000000000000j"), 90000000000000j)
173	self.assertEqual(eval("000000000000007"), 7)
174	self.assertEqual(eval("000000000000008."), 8.)
175	self.assertEqual(eval("000000000000009."), 9.)
176
177	def test_unary_minus(self):
178	# Verify treatment of unary minus on negative numbers SF bug #660455
179	if sys.maxint == 2147483647:
180	# 32-bit machine
181	all_one_bits = '0xffffffff'
182	self.assertEqual(eval(all_one_bits), 4294967295L)
183	self.assertEqual(eval("-" + all_one_bits), -4294967295L)
184	elif sys.maxint == 9223372036854775807:
185	# 64-bit machine
186	all_one_bits = '0xffffffffffffffff'
187	self.assertEqual(eval(all_one_bits), 18446744073709551615L)
188	self.assertEqual(eval("-" + all_one_bits), -18446744073709551615L)
189	else:
190	self.fail("How many bits does this machine have???")
191
192	def test_sequence_unpacking_error(self):
193	# Verify sequence packing/unpacking with "or". SF bug #757818
194	i,j = (1, -1) or (-1, 1)
195	self.assertEqual(i, 1)
196	self.assertEqual(j, -1)
197
198	def test_none_assignment(self):
199	stmts = [
200	'None = 0',
201	'None += 0',
202	'__builtins__.None = 0',
203	'def None(): pass',
204	'class None: pass',
205	'(a, None) = 0, 0',
206	'for None in range(10): pass',
207	'def f(None): pass',
208	]
209	for stmt in stmts:
210	stmt += "\n"
211	self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'single')
212	self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
213
214	def test_import(self):
215	succeed = [
216	'import sys',
217	'import os, sys',
218	'from __future__ import nested_scopes, generators',
219	'from __future__ import (nested_scopes,\ngenerators)',
220	'from __future__ import (nested_scopes,\ngenerators,)',
221	'from sys import stdin, stderr, stdout',
222	'from sys import (stdin, stderr,\nstdout)',
223	'from sys import (stdin, stderr,\nstdout,)',
224	'from sys import (stdin\n, stderr, stdout)',
225	'from sys import (stdin\n, stderr, stdout,)',
226	'from sys import stdin as si, stdout as so, stderr as se',
227	'from sys import (stdin as si, stdout as so, stderr as se)',
228	'from sys import (stdin as si, stdout as so, stderr as se,)',
229	]
230	fail = [
231	'import (os, sys)',
232	'import (os), (sys)',
233	'import ((os), (sys))',
234	'import (sys',
235	'import sys)',
236	'import (os,)',
237	'from (sys) import stdin',
238	'from __future__ import (nested_scopes',
239	'from __future__ import nested_scopes)',
240	'from __future__ import nested_scopes,\ngenerators',
241	'from sys import (stdin',
242	'from sys import stdin)',
243	'from sys import stdin, stdout,\nstderr',
244	'from sys import stdin si',
245	'from sys import stdin,'
246	'from sys import (*)',
247	'from sys import (stdin,, stdout, stderr)',
248	'from sys import (stdin, stdout),',
249	]
250	for stmt in succeed:
251	compile(stmt, 'tmp', 'exec')
252	for stmt in fail:
253	self.assertRaises(SyntaxError, compile, stmt, 'tmp', 'exec')
254
255	def test_for_distinct_code_objects(self):
256	# SF bug 1048870
257	def f():
258	f1 = lambda x=1: x
259	f2 = lambda x=2: x
260	return f1, f2
261	f1, f2 = f()
262	self.assertNotEqual(id(f1.func_code), id(f2.func_code))
263
264	def test_main():
265	test_support.run_unittest(TestSpecifics)
266
267	if __name__ == "__main__":
268	test_main()