1 | #!/usr/bin/env python2
|
2 | from __future__ import print_function
|
3 | """Basic tests for Byterun."""
|
4 |
|
5 | import unittest
|
6 |
|
7 | import six
|
8 |
|
9 | import vmtest
|
10 |
|
11 | PY3, PY2 = six.PY3, not six.PY3
|
12 |
|
13 |
|
14 | class TestIt(vmtest.VmTestCase):
|
15 | def test_constant(self):
|
16 | self.assert_ok("17")
|
17 |
|
18 | def test_globals(self):
|
19 | self.assert_ok("""\
|
20 | global xyz
|
21 | xyz=2106
|
22 |
|
23 | def abc():
|
24 | global xyz
|
25 | xyz+=1
|
26 | print("Midst:",xyz)
|
27 |
|
28 |
|
29 | print "Pre:",xyz
|
30 | abc()
|
31 | print "Post:",xyz
|
32 | """)
|
33 |
|
34 | def test_for_loop(self):
|
35 | self.assert_ok("""\
|
36 | out = ""
|
37 | for i in range(5):
|
38 | out = out + str(i)
|
39 | print(out)
|
40 | """)
|
41 |
|
42 | def test_inplace_operators(self):
|
43 | self.assert_ok("""\
|
44 | x, y = 2, 3
|
45 | x **= y
|
46 | assert x == 8 and y == 3
|
47 | x *= y
|
48 | assert x == 24 and y == 3
|
49 | x //= y
|
50 | assert x == 8 and y == 3
|
51 | x %= y
|
52 | assert x == 2 and y == 3
|
53 | x += y
|
54 | assert x == 5 and y == 3
|
55 | x -= y
|
56 | assert x == 2 and y == 3
|
57 | x <<= y
|
58 | assert x == 16 and y == 3
|
59 | x >>= y
|
60 | assert x == 2 and y == 3
|
61 |
|
62 | x = 0x8F
|
63 | x &= 0xA5
|
64 | assert x == 0x85
|
65 | x |= 0x10
|
66 | assert x == 0x95
|
67 | x ^= 0x33
|
68 | assert x == 0xA6
|
69 | """)
|
70 |
|
71 | if PY2:
|
72 | def test_inplace_division(self):
|
73 | self.assert_ok("""\
|
74 | x, y = 24, 3
|
75 | x /= y
|
76 | assert x == 8 and y == 3
|
77 | assert isinstance(x, int)
|
78 | x /= y
|
79 | assert x == 2 and y == 3
|
80 | assert isinstance(x, int)
|
81 | """)
|
82 | elif PY3:
|
83 | def test_inplace_division(self):
|
84 | self.assert_ok("""\
|
85 | x, y = 24, 3
|
86 | x /= y
|
87 | assert x == 8.0 and y == 3
|
88 | assert isinstance(x, float)
|
89 | x /= y
|
90 | assert x == (8.0/3.0) and y == 3
|
91 | assert isinstance(x, float)
|
92 | """)
|
93 |
|
94 | def test_slice(self):
|
95 | self.assert_ok("""\
|
96 | print("hello, world"[3:8])
|
97 | """)
|
98 | self.assert_ok("""\
|
99 | print("hello, world"[:8])
|
100 | """)
|
101 | self.assert_ok("""\
|
102 | print("hello, world"[3:])
|
103 | """)
|
104 | self.assert_ok("""\
|
105 | print("hello, world"[:])
|
106 | """)
|
107 | self.assert_ok("""\
|
108 | print("hello, world"[::-1])
|
109 | """)
|
110 | self.assert_ok("""\
|
111 | print("hello, world"[3:8:2])
|
112 | """)
|
113 |
|
114 | def test_slice_assignment(self):
|
115 | self.assert_ok("""\
|
116 | l = list(range(10))
|
117 | l[3:8] = ["x"]
|
118 | print(l)
|
119 | """)
|
120 | self.assert_ok("""\
|
121 | l = list(range(10))
|
122 | l[:8] = ["x"]
|
123 | print(l)
|
124 | """)
|
125 | self.assert_ok("""\
|
126 | l = list(range(10))
|
127 | l[3:] = ["x"]
|
128 | print(l)
|
129 | """)
|
130 | self.assert_ok("""\
|
131 | l = list(range(10))
|
132 | l[:] = ["x"]
|
133 | print(l)
|
134 | """)
|
135 |
|
136 | def test_slice_deletion(self):
|
137 | self.assert_ok("""\
|
138 | l = list(range(10))
|
139 | del l[3:8]
|
140 | print(l)
|
141 | """)
|
142 | self.assert_ok("""\
|
143 | l = list(range(10))
|
144 | del l[:8]
|
145 | print(l)
|
146 | """)
|
147 | self.assert_ok("""\
|
148 | l = list(range(10))
|
149 | del l[3:]
|
150 | print(l)
|
151 | """)
|
152 | self.assert_ok("""\
|
153 | l = list(range(10))
|
154 | del l[:]
|
155 | print(l)
|
156 | """)
|
157 | self.assert_ok("""\
|
158 | l = list(range(10))
|
159 | del l[::2]
|
160 | print(l)
|
161 | """)
|
162 |
|
163 | def test_building_stuff(self):
|
164 | self.assert_ok("""\
|
165 | print((1+1, 2+2, 3+3))
|
166 | """)
|
167 | self.assert_ok("""\
|
168 | print([1+1, 2+2, 3+3])
|
169 | """)
|
170 | self.assert_ok("""\
|
171 | print({1:1+1, 2:2+2, 3:3+3})
|
172 | """)
|
173 |
|
174 | def test_subscripting(self):
|
175 | self.assert_ok("""\
|
176 | l = list(range(10))
|
177 | print("%s %s %s" % (l[0], l[3], l[9]))
|
178 | """)
|
179 | self.assert_ok("""\
|
180 | l = list(range(10))
|
181 | l[5] = 17
|
182 | print(l)
|
183 | """)
|
184 | self.assert_ok("""\
|
185 | l = list(range(10))
|
186 | del l[5]
|
187 | print(l)
|
188 | """)
|
189 |
|
190 | def test_generator_expression(self):
|
191 | self.assert_ok("""\
|
192 | x = "-".join(str(z) for z in range(5))
|
193 | assert x == "0-1-2-3-4"
|
194 | """)
|
195 | # From test_regr.py
|
196 | # This failed a different way than the previous join when genexps were
|
197 | # broken:
|
198 | self.assert_ok("""\
|
199 | from textwrap import fill
|
200 | x = set(['test_str'])
|
201 | width = 70
|
202 | indent = 4
|
203 | blanks = ' ' * indent
|
204 | res = fill(' '.join(str(elt) for elt in sorted(x)), width,
|
205 | initial_indent=blanks, subsequent_indent=blanks)
|
206 | print(res)
|
207 | """)
|
208 | def test_list_comprehension(self):
|
209 | self.assert_ok("""\
|
210 | x = [z*z for z in range(5)]
|
211 | assert x == [0, 1, 4, 9, 16]
|
212 | """)
|
213 |
|
214 | def test_dict_comprehension(self):
|
215 | self.assert_ok("""\
|
216 | x = {z:z*z for z in range(5)}
|
217 | assert x == {0:0, 1:1, 2:4, 3:9, 4:16}
|
218 | """)
|
219 |
|
220 | def test_set_comprehension(self):
|
221 | self.assert_ok("""\
|
222 | x = {z*z for z in range(5)}
|
223 | assert x == {0, 1, 4, 9, 16}
|
224 | """)
|
225 |
|
226 | def test_strange_sequence_ops(self):
|
227 | # from stdlib: test/test_augassign.py
|
228 | self.assert_ok("""\
|
229 | x = [1,2]
|
230 | x += [3,4]
|
231 | x *= 2
|
232 |
|
233 | assert x == [1, 2, 3, 4, 1, 2, 3, 4]
|
234 |
|
235 | x = [1, 2, 3]
|
236 | y = x
|
237 | x[1:2] *= 2
|
238 | y[1:2] += [1]
|
239 |
|
240 | assert x == [1, 2, 1, 2, 3]
|
241 | assert x is y
|
242 | """)
|
243 |
|
244 | def test_unary_operators(self):
|
245 | self.assert_ok("""\
|
246 | x = 8
|
247 | print(-x, ~x, not x)
|
248 | """)
|
249 |
|
250 | def test_attributes(self):
|
251 | self.assert_ok("""\
|
252 | l = lambda: 1 # Just to have an object...
|
253 | l.foo = 17
|
254 | print(hasattr(l, "foo"), l.foo)
|
255 | del l.foo
|
256 | print(hasattr(l, "foo"))
|
257 | """)
|
258 |
|
259 | def test_attribute_inplace_ops(self):
|
260 | self.assert_ok("""\
|
261 | l = lambda: 1 # Just to have an object...
|
262 | l.foo = 17
|
263 | l.foo -= 3
|
264 | print(l.foo)
|
265 | """)
|
266 |
|
267 | def test_deleting_names(self):
|
268 | self.assert_ok("""\
|
269 | g = 17
|
270 | assert g == 17
|
271 | del g
|
272 | g
|
273 | """, raises=NameError)
|
274 |
|
275 | def test_deleting_local_names(self):
|
276 | self.assert_ok("""\
|
277 | def f():
|
278 | l = 23
|
279 | assert l == 23
|
280 | del l
|
281 | l
|
282 | f()
|
283 | """, raises=NameError)
|
284 |
|
285 | def test_import(self):
|
286 | self.assert_ok("""\
|
287 | import math
|
288 | print(math.pi, math.e)
|
289 | from math import sqrt
|
290 | print(sqrt(2))
|
291 | from math import *
|
292 | print(sin(2))
|
293 | """)
|
294 |
|
295 | def test_classes(self):
|
296 | self.assert_ok("""\
|
297 | class Thing(object):
|
298 | def __init__(self, x):
|
299 | self.x = x
|
300 | def meth(self, y):
|
301 | return self.x * y
|
302 | thing1 = Thing(2)
|
303 | thing2 = Thing(3)
|
304 | print(thing1.x, thing2.x)
|
305 | print(thing1.meth(4), thing2.meth(5))
|
306 | """)
|
307 |
|
308 | def test_calling_methods_wrong(self):
|
309 | self.assert_ok("""\
|
310 | class Thing(object):
|
311 | def __init__(self, x):
|
312 | self.x = x
|
313 | def meth(self, y):
|
314 | return self.x * y
|
315 | thing1 = Thing(2)
|
316 | print(Thing.meth(14))
|
317 | """, raises=TypeError)
|
318 |
|
319 | def test_calling_subclass_methods(self):
|
320 | self.assert_ok("""\
|
321 | class Thing(object):
|
322 | def foo(self):
|
323 | return 17
|
324 |
|
325 | class SubThing(Thing):
|
326 | pass
|
327 |
|
328 | st = SubThing()
|
329 | print(st.foo())
|
330 | """)
|
331 |
|
332 | def test_subclass_attribute(self):
|
333 | self.assert_ok("""\
|
334 | class Thing(object):
|
335 | def __init__(self):
|
336 | self.foo = 17
|
337 | class SubThing(Thing):
|
338 | pass
|
339 | st = SubThing()
|
340 | print(st.foo)
|
341 | """)
|
342 |
|
343 | def test_subclass_attributes_not_shared(self):
|
344 | self.assert_ok("""\
|
345 | class Thing(object):
|
346 | foo = 17
|
347 | class SubThing(Thing):
|
348 | foo = 25
|
349 | st = SubThing()
|
350 | t = Thing()
|
351 | assert st.foo == 25
|
352 | assert t.foo == 17
|
353 | """)
|
354 |
|
355 | def test_object_attrs_not_shared_with_class(self):
|
356 | self.assert_ok("""\
|
357 | class Thing(object):
|
358 | pass
|
359 | t = Thing()
|
360 | t.foo = 1
|
361 | Thing.foo""", raises=AttributeError)
|
362 |
|
363 | def test_data_descriptors_precede_instance_attributes(self):
|
364 | self.assert_ok("""\
|
365 | class Foo(object):
|
366 | pass
|
367 | f = Foo()
|
368 | f.des = 3
|
369 | class Descr(object):
|
370 | def __get__(self, obj, cls=None):
|
371 | return 2
|
372 | def __set__(self, obj, val):
|
373 | raise NotImplementedError
|
374 | Foo.des = Descr()
|
375 | assert f.des == 2
|
376 | """)
|
377 |
|
378 | def test_instance_attrs_precede_non_data_descriptors(self):
|
379 | self.assert_ok("""\
|
380 | class Foo(object):
|
381 | pass
|
382 | f = Foo()
|
383 | f.des = 3
|
384 | class Descr(object):
|
385 | def __get__(self, obj, cls=None):
|
386 | return 2
|
387 | Foo.des = Descr()
|
388 | assert f.des == 3
|
389 | """)
|
390 |
|
391 | def test_subclass_attributes_dynamic(self):
|
392 | self.assert_ok("""\
|
393 | class Foo(object):
|
394 | pass
|
395 | class Bar(Foo):
|
396 | pass
|
397 | b = Bar()
|
398 | Foo.baz = 3
|
399 | assert b.baz == 3
|
400 | """)
|
401 |
|
402 | def test_attribute_access(self):
|
403 | self.assert_ok("""\
|
404 | class Thing(object):
|
405 | z = 17
|
406 | def __init__(self):
|
407 | self.x = 23
|
408 | t = Thing()
|
409 | print(Thing.z)
|
410 | print(t.z)
|
411 | print(t.x)
|
412 | """)
|
413 |
|
414 | self.assert_ok("""\
|
415 | class Thing(object):
|
416 | z = 17
|
417 | def __init__(self):
|
418 | self.x = 23
|
419 | t = Thing()
|
420 | print(t.xyzzy)
|
421 | """, raises=AttributeError)
|
422 |
|
423 | def test_staticmethods(self):
|
424 | self.assert_ok("""\
|
425 | class Thing(object):
|
426 | @staticmethod
|
427 | def smeth(x):
|
428 | print(x)
|
429 | @classmethod
|
430 | def cmeth(cls, x):
|
431 | print(x)
|
432 |
|
433 | Thing.smeth(1492)
|
434 | Thing.cmeth(1776)
|
435 | """)
|
436 |
|
437 | def test_unbound_methods(self):
|
438 | self.assert_ok("""\
|
439 | class Thing(object):
|
440 | def meth(self, x):
|
441 | print(x)
|
442 | m = Thing.meth
|
443 | m(Thing(), 1815)
|
444 | """)
|
445 |
|
446 | def test_bound_methods(self):
|
447 | self.assert_ok("""\
|
448 | class Thing(object):
|
449 | def meth(self, x):
|
450 | print(x)
|
451 | t = Thing()
|
452 | m = t.meth
|
453 | m(1815)
|
454 | """)
|
455 |
|
456 | def test_callback(self):
|
457 | self.assert_ok("""\
|
458 | def lcase(s):
|
459 | return s.lower()
|
460 | l = ["xyz", "ABC"]
|
461 | l.sort(key=lcase)
|
462 | print(l)
|
463 | assert l == ["ABC", "xyz"]
|
464 | """)
|
465 |
|
466 | def test_unpacking(self):
|
467 | self.assert_ok("""\
|
468 | a, b, c = (1, 2, 3)
|
469 | assert a == 1
|
470 | assert b == 2
|
471 | assert c == 3
|
472 | """)
|
473 |
|
474 | if PY2:
|
475 | def test_exec_statement(self):
|
476 | self.assert_ok("""\
|
477 | g = {}
|
478 | exec "a = 11" in g, g
|
479 | assert g['a'] == 11
|
480 | """)
|
481 | elif PY3:
|
482 | def test_exec_statement(self):
|
483 | self.assert_ok("""\
|
484 | g = {}
|
485 | exec("a = 11", g, g)
|
486 | assert g['a'] == 11
|
487 | """)
|
488 |
|
489 | def test_jump_if_true_or_pop(self):
|
490 | self.assert_ok("""\
|
491 | def f(a, b):
|
492 | return a or b
|
493 | assert f(17, 0) == 17
|
494 | assert f(0, 23) == 23
|
495 | assert f(0, "") == ""
|
496 | """)
|
497 |
|
498 | def test_jump_if_false_or_pop(self):
|
499 | self.assert_ok("""\
|
500 | def f(a, b):
|
501 | return not(a and b)
|
502 | assert f(17, 0) is True
|
503 | assert f(0, 23) is True
|
504 | assert f(0, "") is True
|
505 | assert f(17, 23) is False
|
506 | """)
|
507 |
|
508 | def test_pop_jump_if_true(self):
|
509 | self.assert_ok("""\
|
510 | def f(a):
|
511 | if not a:
|
512 | return 'foo'
|
513 | else:
|
514 | return 'bar'
|
515 | assert f(0) == 'foo'
|
516 | assert f(1) == 'bar'
|
517 | """)
|
518 |
|
519 | def test_decorator(self):
|
520 | self.assert_ok("""\
|
521 | def verbose(func):
|
522 | def _wrapper(*args, **kwargs):
|
523 | return func(*args, **kwargs)
|
524 | return _wrapper
|
525 |
|
526 | @verbose
|
527 | def add(x, y):
|
528 | return x+y
|
529 |
|
530 | add(7, 3)
|
531 | """)
|
532 |
|
533 | def test_multiple_classes(self):
|
534 | # Making classes used to mix together all the class-scoped values
|
535 | # across classes. This test would fail because A.__init__ would be
|
536 | # over-written with B.__init__, and A(1, 2, 3) would complain about
|
537 | # too many arguments.
|
538 | self.assert_ok("""\
|
539 | class A(object):
|
540 | def __init__(self, a, b, c):
|
541 | self.sum = a + b + c
|
542 |
|
543 | class B(object):
|
544 | def __init__(self, x):
|
545 | self.x = x
|
546 |
|
547 | a = A(1, 2, 3)
|
548 | b = B(7)
|
549 | print(a.sum)
|
550 | print(b.x)
|
551 | """)
|
552 |
|
553 |
|
554 | if PY2:
|
555 | class TestPrinting(vmtest.VmTestCase):
|
556 | def test_printing(self):
|
557 | self.assert_ok("print 'hello'")
|
558 | self.assert_ok("a = 3; print a+4")
|
559 | self.assert_ok("""
|
560 | print 'hi', 17, u'bye', 23,
|
561 | print "", "\t", "the end"
|
562 | """)
|
563 |
|
564 | def test_printing_in_a_function(self):
|
565 | self.assert_ok("""\
|
566 | def fn():
|
567 | print "hello"
|
568 | fn()
|
569 | print "bye"
|
570 | """)
|
571 |
|
572 | def test_printing_to_a_file(self):
|
573 | self.assert_ok("""\
|
574 | import sys
|
575 | print >>sys.stdout, 'hello', 'there'
|
576 | """)
|
577 |
|
578 |
|
579 | class TestLoops(vmtest.VmTestCase):
|
580 | def test_for(self):
|
581 | self.assert_ok("""\
|
582 | for i in range(10):
|
583 | print(i)
|
584 | print("done")
|
585 | """)
|
586 |
|
587 | def test_break(self):
|
588 | self.assert_ok("""\
|
589 | for i in range(10):
|
590 | print(i)
|
591 | if i == 7:
|
592 | break
|
593 | print("done")
|
594 | """)
|
595 |
|
596 | def test_continue(self):
|
597 | # fun fact: this doesn't use CONTINUE_LOOP
|
598 | self.assert_ok("""\
|
599 | for i in range(10):
|
600 | if i % 3 == 0:
|
601 | continue
|
602 | print(i)
|
603 | print("done")
|
604 | """)
|
605 |
|
606 | def test_continue_in_try_except(self):
|
607 | self.assert_ok("""\
|
608 | for i in range(10):
|
609 | try:
|
610 | if i % 3 == 0:
|
611 | continue
|
612 | print(i)
|
613 | except ValueError:
|
614 | pass
|
615 | print("done")
|
616 | """)
|
617 |
|
618 | def test_continue_in_try_finally(self):
|
619 | self.assert_ok("""\
|
620 | for i in range(10):
|
621 | try:
|
622 | if i % 3 == 0:
|
623 | continue
|
624 | print(i)
|
625 | finally:
|
626 | print(".")
|
627 | print("done")
|
628 | """)
|
629 |
|
630 |
|
631 | class TestComparisons(vmtest.VmTestCase):
|
632 | def test_in(self):
|
633 | self.assert_ok("""\
|
634 | assert "x" in "xyz"
|
635 | assert "x" not in "abc"
|
636 | assert "x" in ("x", "y", "z")
|
637 | assert "x" not in ("a", "b", "c")
|
638 | """)
|
639 |
|
640 | def test_less(self):
|
641 | self.assert_ok("""\
|
642 | assert 1 < 3
|
643 | assert 1 <= 2 and 1 <= 1
|
644 | assert "a" < "b"
|
645 | assert "a" <= "b" and "a" <= "a"
|
646 | """)
|
647 |
|
648 | def test_greater(self):
|
649 | self.assert_ok("""\
|
650 | assert 3 > 1
|
651 | assert 3 >= 1 and 3 >= 3
|
652 | assert "z" > "a"
|
653 | assert "z" >= "a" and "z" >= "z"
|
654 | """)
|
655 |
|
656 |
|
657 | if __name__ == '__main__':
|
658 | unittest.main()
|