Add python 2.5 reference sources

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
 

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()

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)

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

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()

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'

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

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

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

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__

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)

tests/25_test_exec.ref.py

@@ -0,0 +1,5 @@
+testcode = 'a = 12'
+
+exec testcode
+exec testcode in globals()
+exec testcode in globals(), locals()

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)

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

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

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

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

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

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

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)

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)

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'

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)

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], []])

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'

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

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'

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'

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

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

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)

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

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

tests/25_test_single_stmt.ref.py

@@ -0,0 +1 @@
+print 5

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]

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

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]

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()