diff --git a/tests/22_test_print_to.ref.py b/tests/22_test_print_to.ref.py index 1c78c40..788cc62 100644 --- a/tests/22_test_print_to.ref.py +++ b/tests/22_test_print_to.ref.py @@ -11,10 +11,10 @@ import sys print >>sys.stdout, 1, 2, 3, 4, 5 -print >>sys.stdout, 1, 2, 3, 4, 5, # Should be combined, but left to match line numbers +print >>sys.stdout, 1, 2, 3, 4, 5, print >>sys.stdout -print >>sys.stdout, 1, 2, 3, 4, 5, # Should be combined, but left to match line numbers +print >>sys.stdout, 1, 2, 3, 4, 5, print >>sys.stdout, 1, 2, 3, 4, 5, print >>sys.stdout diff --git a/tests/22_test_yield.ref.py b/tests/22_test_yield.ref.py index 9bcede9..c22d713 100644 --- a/tests/22_test_yield.ref.py +++ b/tests/22_test_yield.ref.py @@ -16,7 +16,7 @@ for i in generate_ints(5): print i, print gen = generate_ints(3) -print gen.next(), # Should be combined, but left separate to match line numbers +print gen.next(), print gen.next(), print gen.next(), print gen.next() diff --git a/tests/25_test_applyEquiv.ref.py b/tests/25_test_applyEquiv.ref.py new file mode 100644 index 0000000..c835360 --- /dev/null +++ b/tests/25_test_applyEquiv.ref.py @@ -0,0 +1,22 @@ +def kwfunc(**kwargs): + print kwargs.items() + +def argsfunc(*args): + print args + +def no_apply(*args, **kwargs): + print args + print kwargs.items() + argsfunc(34) + foo = argsfunc(*args) + argsfunc(*args) + argsfunc(34, *args) + kwfunc(**kwargs) + kwfunc(x=11, **kwargs) + no_apply(*args, **kwargs) + no_apply(34, *args, **kwargs) + no_apply(x=11, *args, **kwargs) + no_apply(34, x=11, *args, **kwargs) + no_apply(42, 34, x=11, *args, **kwargs) + +no_apply(1, 2, 4, 8, a=2, b=3, c=5) diff --git a/tests/25_test_augmentedAssign.ref.py b/tests/25_test_augmentedAssign.ref.py new file mode 100644 index 0000000..094171a --- /dev/null +++ b/tests/25_test_augmentedAssign.ref.py @@ -0,0 +1,66 @@ +""" +augmentedAssign.py -- source test pattern for augmented assigns + +This source is part of the decompyle test suite. + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +raise "This program can't be run" + +a = 1 +b = 2 +a += b +print a +a -= b +print a +a *= b +print a +a -= a +print a +a += 7 * 3 +print a + +l = [1, 2, 3] +l[1] *= 3 +print l[1] +l[1][2][3] = 7 +l[1][2][3] *= 3 +l[:] += [9] +print l +l[:2] += [9] +print l +l[1:] += [9] +print l +l[1:4] += [9] +print l +l += [42, 43] +print l + +a.value = 1 +a.value += 1 +a.b.val = 1 +a.b.val += 1 + +l = [] +for i in range(3): + lj = [] + for j in range(3): + lk = [] + for k in range(3): + lk.append(0) + lj.append(lk) + l.append(lj) + +i = j = k = 1 +def f(): + global i + i += 1 + return i + +l[i][j][k] = 1 +i = 1 +l[f()][j][k] += 1 +print i, l diff --git a/tests/25_test_class.ref.py b/tests/25_test_class.ref.py new file mode 100644 index 0000000..5be125d --- /dev/null +++ b/tests/25_test_class.ref.py @@ -0,0 +1,42 @@ +""" +test_class.py -- source test pattern for class definitions + +This source is part of the decompyle test suite. + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +class A: + class A1: + def __init__(self): + print 'A1.__init__' + + def foo(self): + print 'A1.foo' + + def __init__(self): + print 'A.__init__' + + def foo(self): + print 'A.foo' + + +class B: + def __init__(self): + print 'B.__init__' + + def bar(self): + print 'B.bar' + + +class C(A, B): + def foobar(self): + print 'C.foobar' + + +c = C() +c.foo() +c.bar() +c.foobar() diff --git a/tests/25_test_class_method.pyc b/tests/25_test_class_method.pyc new file mode 100644 index 0000000..e649614 Binary files /dev/null and b/tests/25_test_class_method.pyc differ diff --git a/tests/25_test_class_method.ref.py b/tests/25_test_class_method.ref.py new file mode 100644 index 0000000..e43cea5 --- /dev/null +++ b/tests/25_test_class_method.ref.py @@ -0,0 +1,8 @@ +class MyClass: + def method(self, i): + if i is 5: + print 'five' + elif not (i is 2): + print 'not two' + else: + print '2' diff --git a/tests/25_test_del.ref.py b/tests/25_test_del.ref.py new file mode 100644 index 0000000..baf8e59 --- /dev/null +++ b/tests/25_test_del.ref.py @@ -0,0 +1,35 @@ +""" +test_del.py -- source test pattern for 'del' statements + +This source is part of the decompyle test suite. +Snippet taken from python libs's test_class.py + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +raise "This program can't be run" + +print 0 +a = b[5] +print 1 +del a +print 2 +del b[5] +print 3 + +del testme[1] +print 4 +del testme[:] +print '4a' +del testme[:42] +print '4b' +del testme[40:42] +print 5 +del testme[2:1024:10] +print '5a' +del testme[40, 41, 42] +print 6 +del testme[:42, ..., :24:, 24, 100] +print 7 diff --git a/tests/25_test_divide_future.ref.py b/tests/25_test_divide_future.ref.py new file mode 100644 index 0000000..b9059b9 --- /dev/null +++ b/tests/25_test_divide_future.ref.py @@ -0,0 +1,6 @@ +from __future__ import division + +print ' 1 // 2 =', 1 // 2 +print '1.0 // 2.0 =', 1.0 // 2.0 +print ' 1 / 2 =', 1 / 2 +print '1.0 / 2.0 =', 1.0 / 2.0 diff --git a/tests/25_test_divide_no_future.ref.py b/tests/25_test_divide_no_future.ref.py new file mode 100644 index 0000000..379a500 --- /dev/null +++ b/tests/25_test_divide_no_future.ref.py @@ -0,0 +1,4 @@ +print ' 1 // 2 =', 1 // 2 +print '1.0 // 2.0 =', 1.0 // 2.0 +print ' 1 / 2 =', 1 / 2 +print '1.0 / 2.0 =', 1.0 / 2.0 diff --git a/tests/25_test_docstring.ref.py b/tests/25_test_docstring.ref.py new file mode 100644 index 0000000..7456fa5 --- /dev/null +++ b/tests/25_test_docstring.ref.py @@ -0,0 +1,33 @@ +""" +This is a doc string +""" + +def Doc_Test(): + """This has to be present""" + pass + +class XXX: + def __init__(self): + """__init__: This has to be present""" + self.a = 1 + + def XXX22(): + """XXX22: This has to be present""" + pass + + def XXX11(): + """XXX22: This has to be present""" + pass + + def XXX12(): + foo = 'XXX22: This has to be present' + + def XXX13(): + pass + +def Y11(): + def Y22(): + def Y33(): + pass + +print __doc__ diff --git a/tests/25_test_empty.ref.py b/tests/25_test_empty.ref.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/25_test_exceptions.ref.py b/tests/25_test_exceptions.ref.py new file mode 100644 index 0000000..75fde9a --- /dev/null +++ b/tests/25_test_exceptions.ref.py @@ -0,0 +1,107 @@ +import dis + +def x11(): + try: + a = 'try except' + except: + a = 2 + b = '--------' + + +def x12(): + try: + a = 'try except else(pass)' + except: + a = 2 + b = '--------' + + +def x13(): + try: + a = 'try except else(a=3)' + except: + a = 2 + else: + a = 3 + b = '--------' + + +def x21(): + try: + a = 'try KeyError' + except KeyError: + a = 8 + b = '--------' + + +def x22(): + try: + a = 'try (IdxErr, KeyError) else(pass)' + except (IndexError, KeyError): + a = 8 + b = '--------' + + +def x23(): + try: + a = 'try KeyError else(a=9)' + except KeyError: + a = 8 + else: + a = 9 + b = '--------' + + +def x31(): + try: + a = 'try KeyError IndexError' + except KeyError: + a = 8 + except IndexError: + a = 9 + b = '--------' + + +def x32(): + try: + a = 'try KeyError IndexError else(pass)' + except KeyError: + a = 8 + except IndexError: + a = 9 + b = '--------' + + +def x33(): + try: + a = 'try KeyError IndexError else(a=9)' + except KeyError: + a = 8 + except IndexError: + a = 9 + else: + a = 9 + b = '#################' + + +def x41(): + if a == 1: + a = 1 + elif b == 1: + b = 1 + else: + c = 1 + b = '#################' + + +def x42(): + if a == 1: + a = 1 + elif b == 1: + b = 1 + else: + c = 1 + xxx = 'mmm' + +if __name__ == '__main__': + dis.dis(xx) diff --git a/tests/25_test_exec.ref.py b/tests/25_test_exec.ref.py new file mode 100644 index 0000000..b43984e --- /dev/null +++ b/tests/25_test_exec.ref.py @@ -0,0 +1,5 @@ +testcode = 'a = 12' + +exec testcode +exec testcode in globals() +exec testcode in globals(), locals() diff --git a/tests/25_test_expressions.ref.py b/tests/25_test_expressions.ref.py new file mode 100644 index 0000000..fbb1004 --- /dev/null +++ b/tests/25_test_expressions.ref.py @@ -0,0 +1,2 @@ +def _lsbStrToInt(str): + return ord(str[0]) + (ord(str[1]) << 8) + (ord(str[2]) << 16) + (ord(str[3]) << 24) diff --git a/tests/25_test_extendedImport.ref.py b/tests/25_test_extendedImport.ref.py new file mode 100644 index 0000000..887353b --- /dev/null +++ b/tests/25_test_extendedImport.ref.py @@ -0,0 +1,10 @@ +import os +import sys as System +import time +import sys +from rfc822 import Message as Msg822 +from mimetools import Message as MimeMsg, decode, choose_boundary as MimeBoundary +import test.test_StringIO as StringTest + +for k, v in globals().items(): + print `k`, v diff --git a/tests/25_test_extendedPrint.ref.py b/tests/25_test_extendedPrint.ref.py new file mode 100644 index 0000000..6a7bba2 --- /dev/null +++ b/tests/25_test_extendedPrint.ref.py @@ -0,0 +1,6 @@ +import sys + +print >>sys.stdout, 'Hello World' +print >>sys.stdout, 1, 2, 3 +print >>sys.stdout, 1, 2, 3, +print >>sys.stdout diff --git a/tests/25_test_functions.ref.py b/tests/25_test_functions.ref.py new file mode 100644 index 0000000..c9bdf17 --- /dev/null +++ b/tests/25_test_functions.ref.py @@ -0,0 +1,50 @@ +def x0(): + pass + +def x1(arg1): + pass + +def x2(arg1, arg2): + pass + +def x3a(*args): + pass + +def x3b(**kwargs): + pass + +def x3c(*args, **kwargs): + pass + +def x4a(foo, bar = 1, bla = 2, *args): + pass + +def x4b(foo, bar = 1, bla = 2, **kwargs): + pass + +def x4c(foo, bar = 1, bla = 2, *args, **kwargs): + pass + +def func_with_tuple_args((a, b)): + print a + print b + +def func_with_tuple_args2((a, b), (c, d)): + print a + print c + +def func_with_tuple_args3((a, b), (c, d), *args): + print a + print c + +def func_with_tuple_args4((a, b), (c, d), **kwargs): + print a + print c + +def func_with_tuple_args5((a, b), (c, d), *args, **kwargs): + print a + print c + +def func_with_tuple_args6((a, b), (c, d) = (2, 3), *args, **kwargs): + print a + print c diff --git a/tests/25_test_global.ref.py b/tests/25_test_global.ref.py new file mode 100644 index 0000000..1a0e35a --- /dev/null +++ b/tests/25_test_global.ref.py @@ -0,0 +1,31 @@ +""" +test_global.py -- source test pattern for 'global' statement + +This source is part of the decompyle test suite. + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +i = 1 +j = 7 + +def a(): + def b(): + global j + + def c(): + global i + k = 34 + i = i + k + + l = 42 + c() + j = j + l + + b() + print i, j + +a() +print i, j diff --git a/tests/25_test_globals.ref.py b/tests/25_test_globals.ref.py new file mode 100644 index 0000000..b9a7361 --- /dev/null +++ b/tests/25_test_globals.ref.py @@ -0,0 +1,10 @@ +def f(): + print x + x = x + 1 + print x + +raise "This program can't be run" + +x = 1 +f() +print x diff --git a/tests/25_test_import.ref.py b/tests/25_test_import.ref.py new file mode 100644 index 0000000..3cbf2c8 --- /dev/null +++ b/tests/25_test_import.ref.py @@ -0,0 +1,19 @@ +""" +test_import.py -- source test pattern for import statements + +This source is part of the decompyle test suite. + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +import sys +import os, sys, BaseHTTPServer +import test.test_MimeWriter +from rfc822 import Message +from mimetools import Message, decode, choose_boundary +from os import * + +for (k, v) in globals().items(): + print `k`, v diff --git a/tests/25_test_import_as.ref.py b/tests/25_test_import_as.ref.py new file mode 100644 index 0000000..356456b --- /dev/null +++ b/tests/25_test_import_as.ref.py @@ -0,0 +1,22 @@ +""" +test_import_as.py -- source test pattern for 'import .. as 'statements + +This source is part of the decompyle test suite. + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +import sys as SYS +import os as OS +import sys as SYSTEM +import BaseHTTPServer as HTTPServ +import test.test_MimeWriter as Mime_Writer +from rfc822 import Message as MSG +from mimetools import Message as mimeMsg, decode, choose_boundary as mimeBoundry + +print '---' * 20 + +for k, v in globals().items(): + print k, repr(v) diff --git a/tests/25_test_integers.ref.py b/tests/25_test_integers.ref.py new file mode 100644 index 0000000..21da85d --- /dev/null +++ b/tests/25_test_integers.ref.py @@ -0,0 +1,31 @@ +""" +test_integers.py -- source test pattern for integers + +This source is part of the decompyle test suite. +Snippet taken from python libs's test_class.py + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +import sys + +i = 1 +i = 42 +i = -1 +i = -42 +i = sys.maxint +minint = -sys.maxint - 1 +print sys.maxint +print minint +print long(minint) - 1 +print +i = -2147483647 +print i, repr(i) +i = i - 1 +print i, repr(i) +i = -0x80000000L +print i, repr(i) +i = -0x80000001L +print i, repr(i) diff --git a/tests/25_test_iterators.ref.py b/tests/25_test_iterators.ref.py new file mode 100644 index 0000000..2ee41d5 --- /dev/null +++ b/tests/25_test_iterators.ref.py @@ -0,0 +1,8 @@ +for i in range(20): + print i, +print + +for i in range(10): + print i, +else: + print 'The End' diff --git a/tests/25_test_lambda.ref.py b/tests/25_test_lambda.ref.py new file mode 100644 index 0000000..8bd45b0 --- /dev/null +++ b/tests/25_test_lambda.ref.py @@ -0,0 +1,7 @@ +palette = map(lambda a: (a, a, a), range(256)) +palette = map(lambda (r, g, b): chr(r) + chr(g) + chr(b), palette) +palette = map(lambda r: r, palette) +palette = lambda (r, g, b): r +palette = lambda (r): r +palette = lambda r: r +palette = (lambda (r): r, palette) diff --git a/tests/25_test_listComprehensions.ref.py b/tests/25_test_listComprehensions.ref.py new file mode 100644 index 0000000..d423f84 --- /dev/null +++ b/tests/25_test_listComprehensions.ref.py @@ -0,0 +1,23 @@ +XXX = range(4) + +print [i for i in XXX] +print +print [i for i in (1, 2, 3, 4)] +print +print [(i, 1) for i in XXX] +print +print [i * 2 for i in range(4)] +print +print [i * j for i in range(4) for j in range(7)] +print [i * 2 for i in range(4) if i == 0] +print [(i, i ** 2) for i in range(4) if i % 2 == 0] +print [i * j for i in range(4) if i == 2 for j in range(7) if i + (i % 2) == 0] + +seq1 = 'abc' +seq2 = (1, 2, 3) +[(x, y) for x in seq1 for y in seq2] + +def flatten(seq): + return [x for subseq in seq for x in subseq] + +print flatten([[0], [1, 2, 3], [4, 5], [6, 7, 8, 9], []]) diff --git a/tests/25_test_loops.ref.py b/tests/25_test_loops.ref.py new file mode 100644 index 0000000..d8d8aad --- /dev/null +++ b/tests/25_test_loops.ref.py @@ -0,0 +1,47 @@ +""" +test_loops.py -- source test pattern for loops + +This source is part of the decompyle test suite. + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +for i in range(10): + if i == 3: + continue + if i == 5: + break + print i, +else: + print 'Else' +print + +for i in range(10): + if i == 3: + continue + print i, +else: + print 'Else' + +i = 0 +while i < 10: + i = i + 1 + if i == 3: + continue + if i == 5: + break + print i, +else: + print 'Else' +print + +i = 0 +while i < 10: + i = i + 1 + if i == 3: + continue + print i, +else: + print 'Else' diff --git a/tests/25_test_loops2.ref.py b/tests/25_test_loops2.ref.py new file mode 100644 index 0000000..a50cc0b --- /dev/null +++ b/tests/25_test_loops2.ref.py @@ -0,0 +1,17 @@ +""" +test_loops2.py -- source test pattern for loops (CONTINUE_LOOP) + +This source is part of the decompyle test suite. + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +for term in args: + try: + print + continue + print + except: + pass diff --git a/tests/25_test_misc.ref.py b/tests/25_test_misc.ref.py new file mode 100644 index 0000000..e482c4a --- /dev/null +++ b/tests/25_test_misc.ref.py @@ -0,0 +1,23 @@ +raise "This program can't be run" + +class A: + def __init__(self, num): + self.num = num + + def __repr__(self): + return str(self.num) + +b = [] +for i in range(10): + b.append(A(i)) + +for i in ('CALL_FUNCTION', 'CALL_FUNCTION_VAR', 'CALL_FUNCTION_VAR_KW', 'CALL_FUNCTION_KW'): + print i, '\t', len(i), len(i) - len('CALL_FUNCTION'), + print (len(i) - len('CALL_FUNCTION')) / 3, + print i[len('CALL_FUNCTION'):] + +p2 = (0, 0, None) +if p2[2]: + print 'has value' +else: + print ' no value' diff --git a/tests/25_test_nested_elif.ref.py b/tests/25_test_nested_elif.ref.py new file mode 100644 index 0000000..0006b1f --- /dev/null +++ b/tests/25_test_nested_elif.ref.py @@ -0,0 +1,77 @@ +a = None + +if a == 1: + print '1' +elif a == 2: + print '2' + +if a == 1: + print '1' +elif a == 2: + print '2' +else: + print 'other' + +if a == 1: + print '1' +elif a == 2: + print '2' +elif a == 3: + print '3' +else: + print 'other' + +if a == 1: + print '1' +elif a == 2: + print '2' +elif a == 3: + print '3' + +if a == 1: + print '1' +elif a ==2: + print '2' +elif a == 3: + print '3' +else: + print 'other' + +if a == 1: + print '1' +elif a == 2: + print '2' +else: + print 'more' + if a == 3: + print '3' + else: + print 'other' + +if a == 1: + print '1' +else: + print 'more' + if a == 2: + print '2' + elif a == 3: + print '3' + else: + print 'other' + +if a == 1: + print '1' +else: + print 'more' + if a == 2: + print '2' + else: + print 'more' + if a == 3: + print '3' + elif a == 4: + print '4' + elif a == 4: + print '4' + else: + print 'other' diff --git a/tests/25_nested_ifs.pyc b/tests/25_test_nested_ifs.pyc similarity index 100% rename from tests/25_nested_ifs.pyc rename to tests/25_test_nested_ifs.pyc diff --git a/tests/25_test_nested_ifs.ref.py b/tests/25_test_nested_ifs.ref.py new file mode 100644 index 0000000..60af943 --- /dev/null +++ b/tests/25_test_nested_ifs.ref.py @@ -0,0 +1,13 @@ +import random + +i = random.randint(0, 5) +if i is 1: + print '%d is 1' % i +elif i < 5: + print '%d less than 5' % i + if i is 3: + print '%d = 3' % i + else: + print '%d != 3' % i +else: + print '%d is 5' % i diff --git a/tests/25_test_nested_scopes.ref.py b/tests/25_test_nested_scopes.ref.py new file mode 100644 index 0000000..aee6347 --- /dev/null +++ b/tests/25_test_nested_scopes.ref.py @@ -0,0 +1,90 @@ +from __future__ import nested_scopes + +blurb = 1 + +def k0(): + def l0(m = 1): + print + l0() + +def x0(): + def y0(): + print + y0() + +def x1(): + def y1(): + print 'y-blurb =', blurb + y1() + +def x2(): + def y2(): + print + blurb = 2 + y2() + +def x3a(): + def y3a(x): + print 'y-blurb =', blurb, flurb + print + blurb = 3 + flurb = 7 + y3a(1) + print 'x3a-blurb =', blurb + +def x3(): + def y3(x): + def z(): + blurb = 25 + print 'z-blurb =', blurb, + z() + print 'y-blurb =', blurb, + print + blurb = 3 + y3(1) + print 'x3-blurb =', blurb + +def x3b(): + def y3b(x): + def z(): + print 'z-blurb =', blurb, + blurb = 25 + z() + print 'y-blurb =', blurb, + print + blurb = 3 + y3b(1) + print 'x3-blurb =', blurb + +def x4(): + def y4(x): + def z(): + print 'z-blurb =', blurb + z() + global blurb + blurb = 3 + y4(1) + +def x(): + def y(x): + print 'y-blurb =', blurb + blurb = 2 + y(1) + +def func_with_tuple_args6((a, b), (c, d) = (2, 3), *args, **kwargs): + def y(x): + print 'y-a =', a + print c + +def find(self, name): + L = filter(lambda x, name: x == name, self.list_attribute) + +x0() +x1() +x2() +x3() +x3a() +x3b() +x4() +x() +print 'blurb =', blurb diff --git a/tests/25_test_prettyprint.ref.py b/tests/25_test_prettyprint.ref.py new file mode 100644 index 0000000..70a0084 --- /dev/null +++ b/tests/25_test_prettyprint.ref.py @@ -0,0 +1,142 @@ +""" +test_prettyprint.py -- source test pattern for tesing the prettyprint + funcionality of decompyle + +This source is part of the decompyle test suite. + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +import pprint + +aa = 'aa' + +dict0 = { + 'a': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + 'b': 1234, + 'd': aa, + aa: aa +} + +dict = { + 'a': 'aaa', + 'b': 1234, + 'c': { + 'ca': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + 'cb': 1234, + 'cc': None + }, + 'd': aa, + aa: aa, + 'eee': { + 'ca': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + 'cb': 1234, + 'cc': None + }, + 'ff': aa +} + +list1 = ['1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', aa, + '1bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + '1ccccccccccccccccccccccccccccccccccccccccccc'] + +list2 = ['2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + ['22aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', aa, + '22bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + '22ccccccccccccccccccccccccccccccccccccccccccc'], + 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + 'ccccccccccccccccccccccccccccccccccccccccccc'] + +tuple1 = ('1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', aa, + '1bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + '1ccccccccccccccccccccccccccccccccccccccccccc') + +tuple2 = ('2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + ('22aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', aa, + '22bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + '22ccccccccccccccccccccccccccccccccccccccccccc'), + 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + 'ccccccccccccccccccccccccccccccccccccccccccc') + + +def funcA(): + dict = { + 'a': 'aaa', + 'b': 1234, + 'c': { + 'ca': 'aaa', + 'cb': 1234, + 'cc': None + }, + 'd': aa, + aa: aa + } + + list1 = ['1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + '1bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', aa, + '1ccccccccccccccccccccccccccccccccccccccccccc'] + + list2 = ['2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + ['22aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', aa, + '22bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + '22ccccccccccccccccccccccccccccccccccccccccccc'], + 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + 'ccccccccccccccccccccccccccccccccccccccccccc'] + + tuple1 = ('1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + '1bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', aa, + '1ccccccccccccccccccccccccccccccccccccccccccc') + + tuple2 = ('2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + ('22aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', aa, + '22bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + '22ccccccccccccccccccccccccccccccccccccccccccc'), + 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + 'ccccccccccccccccccccccccccccccccccccccccccc') + + def funcAB(): + dict = { + 'a': 'aaa', + 'b': 1234, + 'c': { + 'ca': 'aaa', + 'cb': 1234, + 'cc': None + }, + 'd': aa, + aa: aa + } + + list1 = ['1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + '1bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + '1ccccccccccccccccccccccccccccccccccccccccccc'] + list2= ['2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + ['22aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + '22bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + '22ccccccccccccccccccccccccccccccccccccccccccc'], + 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + 'ccccccccccccccccccccccccccccccccccccccccccc'] + tuple1 = ('1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + '1bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + '1ccccccccccccccccccccccccccccccccccccccccccc') + tuple2 = ('2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + ('22aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa', + '22bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + '22ccccccccccccccccccccccccccccccccccccccccccc'), + 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb', + 'ccccccccccccccccccccccccccccccccccccccccccc') + +pprint.pprint(dict0) +print +pprint.pprint(dict) +print +pprint = pprint.PrettyPrinter(indent = 2) +pprint.pprint(dict0) +print +pprint.pprint(dict) +print +pprint.pprint(list1) +print +pprint.pprint(list2) diff --git a/tests/25_test_print.ref.py b/tests/25_test_print.ref.py new file mode 100644 index 0000000..4f0e071 --- /dev/null +++ b/tests/25_test_print.ref.py @@ -0,0 +1,8 @@ +print 1, 2, 3, 4, 5 +a = b + 5 +print 1, 2, 3, 4, 5 +print 1, 2, 3, 4, 5 +print +print +print 1, 2, 3, 4, 5 +print diff --git a/tests/25_test_print_to.ref.py b/tests/25_test_print_to.ref.py new file mode 100644 index 0000000..fc68931 --- /dev/null +++ b/tests/25_test_print_to.ref.py @@ -0,0 +1,19 @@ +""" +print_to.py -- source test pattern for 'print >> ...' statements + +This source is part of the decompyle test suite. + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +import sys + +print >>sys.stdout, 1, 2, 3, 4, 5 +print >>sys.stdout, 1, 2, 3, 4, 5, +print >>sys.stdout +print >>sys.stdout, 1, 2, 3, 4, 5, +print >>sys.stdout, 1, 2, 3, 4, 5, +print >>sys.stdout +print >>sys.stdout diff --git a/tests/25_test_single_stmt.ref.py b/tests/25_test_single_stmt.ref.py new file mode 100644 index 0000000..79a0780 --- /dev/null +++ b/tests/25_test_single_stmt.ref.py @@ -0,0 +1 @@ +print 5 diff --git a/tests/25_test_slices.ref.py b/tests/25_test_slices.ref.py new file mode 100644 index 0000000..71c4780 --- /dev/null +++ b/tests/25_test_slices.ref.py @@ -0,0 +1,37 @@ +""" +test_slices.py -- source test pattern for slices + +This source is part of the decompyle test suite. +Snippet taken from python libs's test_class.py + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +raise "This program can't be run" + +testme[1] +testme[1] = 1 +del testme[1] +testme[:42] +testme[:42] = 'The Answer' +del testme[:42] +testme[2:1024:] +testme[:1024:10] +testme[::] +testme[2:1024:10] +testme[2:1024:10] = 'A lot' +del testme[2:1024:10] +testme[:42, ..., :24:, 24, 100] +testme[:42, ..., :24:, 24, 100] = 'Strange' +del testme[:42, ..., :24:, 24, 100] +testme[:] +testme[:] = 'Take all' +del testme[:] +testme[40:42] +testme[40:42] = 'Three' +del testme[40:42] +testme[40, 41, 42] +testme[40, 41, 42] = 'Another Three' +del testme[40, 41, 42] diff --git a/tests/25_test_tuple_params.ref.py b/tests/25_test_tuple_params.ref.py new file mode 100644 index 0000000..50dd4bf --- /dev/null +++ b/tests/25_test_tuple_params.ref.py @@ -0,0 +1,24 @@ +""" +test_tuple_params.py -- source test pattern for formal parameters of type tuple + +This source is part of the decompyle test suite. + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +def A(a, b, (x, y, z), c): + pass + +def B(a, b = 42, (x, y, z) = (1, 2, 3), c = 17): + pass + +def C((x, y, z)): + pass + +def D((x,)): + pass + +def E(x): + pass diff --git a/tests/25_test_tuples.ref.py b/tests/25_test_tuples.ref.py new file mode 100644 index 0000000..c540699 --- /dev/null +++ b/tests/25_test_tuples.ref.py @@ -0,0 +1,26 @@ +""" +test_tuples.py -- source test pattern for tuples + +This source is part of the decompyle test suite. + +decompyle is a Python byte-code decompiler +See http://www.goebel-consult.de/decompyle/ for download and +for further information +""" + +a = (1,) +b = (2, 3) +a, b = (1, 2) +a, b = (1, 2), (3, 4, 5) +x = {} + +try: + x[1, 2, 3] +except: + pass + +x[1, 2, 3] = 42 +print x[1, 2, 3] +print x[1, 2, 3] +assert x[1, 2, 3] == x[1, 2, 3] +del x[1, 2, 3] diff --git a/tests/25_test_yield.ref.py b/tests/25_test_yield.ref.py new file mode 100644 index 0000000..c22d713 --- /dev/null +++ b/tests/25_test_yield.ref.py @@ -0,0 +1,22 @@ +from __future__ import generators + +def inorder(t): + if t: + for x in inorder(t.left): + yield x + yield t.label + for x in inorder(t.right): + yield x + +def generate_ints(n): + for i in range(n): + yield i * 2 + +for i in generate_ints(5): + print i, +print +gen = generate_ints(3) +print gen.next(), +print gen.next(), +print gen.next(), +print gen.next()