Beispiel #1
0
    def test_01reblok(self):
        for root, dirs, files in os.walk(self.snippets):
            for f in files:
                if not f.endswith('.pyc'):
                    continue

                tmp = tempfile.mkstemp(prefix='reblok-')
                print os.path.join(root, f), tmp, type(tmp)
                ret = subprocess.call(
                    ['reblok', os.path.join(root, f)], stdout=tmp[0])
                # validation #1: reblok mist return 0 value
                self.assertEqual(ret, 0)

                # validation #2: we compare AST generated by source file and reblok-output
                # file
                with open(os.path.join(root, f)) as fh:
                    fh.seek(8)
                    bytecode = marshal.load(fh)

                tree = Parser().walk(bytecode)

                try:
                    with open(tmp[1]) as fh:
                        bytecode = compile(fh.read(), '<string>', 'exec')
                except SyntaxError:
                    self.fail('%s: invalid source file (%s)' % (f, tmp[1]))

                tree2 = Parser().walk(bytecode)
                import pprint
                pprint.pprint(tree)
                pprint.pprint(tree2)
                self.assertEqual(tree, tree2)
Beispiel #2
0
    def __init__(self, *args, **kwargs):
        unittest.TestCase.__init__(self, *args, **kwargs)
        self.parser = Parser()

        # compile snippets
        self.snippets = os.path.join(os.path.dirname(sys.argv[0]), 'snippets')
        compileall.compile_dir(self.snippets)
Beispiel #3
0
	def __init__(self, *args, **kwargs):
		unittest.TestCase.__init__(self, *args, **kwargs)
		self.parser = Parser()

		# compile snippets
		self.snippets = os.path.join(os.path.dirname(sys.argv[0]), 'snippets')
		compileall.compile_dir(self.snippets)
Beispiel #4
0
class TestReblokBasics(unittest.TestCase):
	def __init__(self, *args, **kwargs):
		unittest.TestCase.__init__(self, *args, **kwargs)
		self.parser = Parser()

		# compile snippets
		self.snippets = os.path.join(os.path.dirname(sys.argv[0]), 'snippets')
		compileall.compile_dir(self.snippets)

	def walk(code):
		return self.parser.walk(code)

	def test_01reblok(self):
		for root, dirs, files in os.walk(self.snippets):
			for f in files:
				if not f.endswith('.pyc'):
					continue

				tmp = tempfile.mkstemp(prefix='reblok-')
				print os.path.join(root,f), tmp, type(tmp)
				ret = subprocess.call(['reblok', os.path.join(root, f)], stdout=tmp[0])
				# validation #1: reblok mist return 0 value
				self.assertEqual(ret, 0)

				# validation #2: we compare AST generated by source file and reblok-output
				# file
				with open(os.path.join(root,f)) as fh:
					fh.seek(8)
					bytecode = marshal.load(fh)

				tree = Parser().walk(bytecode)

				try:
					with open(tmp[1]) as fh:
						bytecode = compile(fh.read(), '<string>', 'exec')
				except SyntaxError:
					self.fail('%s: invalid source file (%s)' % (f, tmp[1]))

				tree2 = Parser().walk(bytecode)
				import pprint; pprint.pprint(tree); pprint.pprint(tree2)
				self.assertEqual(tree, tree2)
Beispiel #5
0
	def __init__(self, *args, **kwargs):
		unittest.TestCase.__init__(self, *args, **kwargs)
		self.parser = Parser()
Beispiel #6
0
class TestReblokBasics(unittest.TestCase):
	def __init__(self, *args, **kwargs):
		unittest.TestCase.__init__(self, *args, **kwargs)
		self.parser = Parser()

	def walk(code):
		return self.parser.walk(code)

	def test_01arithmetic(self):
		tree = self.parser.walk(lambda u: u + 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.ADD, (op.VAR, 'u', ns.LOCAL), (op.CONST , 5))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u - 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.SUB, (op.VAR, 'u', ns.LOCAL), (op.CONST , 5))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u * 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.MUL, (op.VAR, 'u', ns.LOCAL), (op.CONST , 5))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u / 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.DIV, (op.VAR, 'u', ns.LOCAL), (op.CONST , 5))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u % 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.MOD, (op.VAR, 'u', ns.LOCAL), (op.CONST , 5))]],
				[('u', op.UNDEF)], None, None, [], {}
		])
	
	def test_02cmp(self):
		tree = self.parser.walk(lambda u: u == 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA, [
				[op.RET,
					(op.EQ,
						(op.VAR  , 'u', ns.LOCAL),
						(op.CONST, 5)
				)]],
				[('u', op.UNDEF)], None, None, [], {}]
		)

		tree = self.parser.walk(lambda u: u != 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.NEQ, (op.VAR, 'u', ns.LOCAL), (op.CONST , 5))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		# <> and != are same operator
		tree = self.parser.walk(lambda u: u <> 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.NEQ, (op.VAR, 'u', ns.LOCAL), (op.CONST , 5))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u > 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.GT, (op.VAR, 'u', ns.LOCAL), (op.CONST , 5))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u < 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.LT, (op.VAR, 'u', ns.LOCAL), (op.CONST , 5))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u >= 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.GEQ, (op.VAR, 'u', ns.LOCAL), (op.CONST , 5))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u <= 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.LEQ, (op.VAR, 'u', ns.LOCAL), (op.CONST , 5))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u is 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.ID, (op.VAR, 'u', ns.LOCAL), (op.CONST , 5))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u is not 5)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.NID, (op.VAR, 'u', ns.LOCAL), (op.CONST , 5))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

	def test_03bool(self):
		tree = self.parser.walk(lambda u: u or True)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.OR, (op.VAR, 'u', ns.LOCAL), (op.CONST , True)]]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: True or u)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.OR, (op.CONST , True), (op.VAR, 'u', ns.LOCAL)]]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u and True)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.AND, (op.VAR, 'u', ns.LOCAL), (op.CONST , True)]]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: True and u)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.AND, (op.CONST , True), (op.VAR, 'u', ns.LOCAL)]]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: not u)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.NOT, (op.VAR, 'u', ns.LOCAL))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: not u or True)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.OR, (op.NOT, (op.VAR, 'u', ns.LOCAL)), (op.CONST , True)]]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: not (u or True))
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.NOT, [op.OR, (op.VAR, 'u', ns.LOCAL), (op.CONST , True)])]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: not u and True)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.AND, (op.NOT, (op.VAR, 'u', ns.LOCAL)), (op.CONST , True)]]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: not (u and True))
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.NOT, [op.AND, (op.VAR, 'u', ns.LOCAL), (op.CONST , True)])]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: a or b and c)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.OR, (op.VAR, 'a', ns.GLOBAL), [op.AND, (op.VAR, 'b', ns.GLOBAL), (op.VAR, 'c', ns.GLOBAL)]]]],
				[('u', op.UNDEF)], None, None, ['a', 'b', 'c'], {}
		])

		tree = self.parser.walk(lambda u: a or (b and c))
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.OR, (op.VAR, 'a', ns.GLOBAL), [op.AND, (op.VAR, 'b', ns.GLOBAL), (op.VAR, 'c', ns.GLOBAL)]]]],
				[('u', op.UNDEF)], None, None, ['a', 'b', 'c'], {}
		])

		tree = self.parser.walk(lambda u: (a or b) and c)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.AND, [op.OR, (op.VAR, 'a', ns.GLOBAL), (op.VAR, 'b', ns.GLOBAL)], (op.VAR, 'c', ns.GLOBAL)]]],
				[('u', op.UNDEF)], None, None, ['a', 'b', 'c'], {}
		])

		tree = self.parser.walk(lambda u: a and b or c)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.OR, [op.AND, (op.VAR, 'a', ns.GLOBAL), (op.VAR, 'b', ns.GLOBAL)], (op.VAR, 'c', ns.GLOBAL)]]],
				[('u', op.UNDEF)], None, None, ['a', 'b', 'c'], {}
		])

		tree = self.parser.walk(lambda u: a and (b or c))
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.AND, (op.VAR, 'a', ns.GLOBAL), [op.OR, (op.VAR, 'b', ns.GLOBAL), (op.VAR, 'c', ns.GLOBAL)]]]],
				[('u', op.UNDEF)], None, None, ['a', 'b', 'c'], {}
		])

		tree = self.parser.walk(lambda u: a and b or c and d)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.OR, 
					[op.AND, (op.VAR, 'a', ns.GLOBAL), (op.VAR, 'b', ns.GLOBAL)], 
					[op.AND, (op.VAR, 'c', ns.GLOBAL), (op.VAR, 'd', ns.GLOBAL)]
				]]],
				[('u', op.UNDEF)], None, None, ['a', 'b', 'c', 'd'], {}
		])

		tree = self.parser.walk(lambda u: a or b and c or d)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.OR, 
					(op.VAR, 'a', ns.GLOBAL), 
					[op.OR, 
						[op.AND, (op.VAR, 'b', ns.GLOBAL), (op.VAR, 'c', ns.GLOBAL)],
						(op.VAR, 'd', ns.GLOBAL)]
				]]],
				[('u', op.UNDEF)], None, None, ['a', 'b', 'c', 'd'], {}
		])


	def test_04list(self):
		tree = self.parser.walk(lambda a,b: (1, plop, a.name, "Zzz", b))
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.TUPLE, [
					(op.CONST, 1), (op.VAR, 'plop', ns.GLOBAL), 
					(op.ATTR, (op.VAR, 'a', ns.LOCAL), 'name'),
					(op.CONST, 'Zzz'), (op.VAR, 'b', ns.LOCAL)])]],
				[('a', op.UNDEF), ('b', op.UNDEF)], None, None, ['plop'], {}
		])

		tree = self.parser.walk(lambda a,b: [1, 'plop', True, 3.14, foo])
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.LIST, [
					(op.CONST, 1), (op.CONST, 'plop'), (op.CONST, True), (op.CONST, 3.14), (op.VAR, 'foo', ns.GLOBAL)])]],
				[('a', op.UNDEF), ('b', op.UNDEF)], None, None, ['foo'], {}
		])

		tree = self.parser.walk(lambda u: u[0])
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.AT, (op.VAR, 'u', ns.LOCAL), (op.CONST, 0))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u[:])
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.SLICE, (op.VAR, 'u', ns.LOCAL), None, None)]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u[1:])
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.SLICE, (op.VAR, 'u', ns.LOCAL), (op.CONST, 1), None)]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u[:1])
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.SLICE, (op.VAR, 'u', ns.LOCAL), None, (op.CONST, 1))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u[5:2])
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.SLICE, (op.VAR, 'u', ns.LOCAL), (op.CONST, 5), (op.CONST, 2))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: a in b)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.IN, (op.VAR, 'a', ns.GLOBAL), (op.VAR, 'b', ns.GLOBAL))]],
				[('u', op.UNDEF)], None, None, ['a', 'b'], {}
		])

		tree = self.parser.walk(lambda u: a not in b)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.NIN, (op.VAR, 'a', ns.GLOBAL), (op.VAR, 'b', ns.GLOBAL))]],
				[('u', op.UNDEF)], None, None, ['a', 'b'], {}
		])

	
	def test_05dict(self):
		tree = self.parser.walk(lambda u: {'name': 'doe', 'age': 42})
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.DICT, [
					((op.CONST, 'name'), (op.CONST, 'doe')),
					((op.CONST, 'age') , (op.CONST, 42))
				])]],
				[('u', op.UNDEF)], None, None, [], {}
		])


	def test_06attr(self):
		tree = self.parser.walk(lambda u: u.name)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.ATTR, (op.VAR, 'u', ns.LOCAL), 'name')]],
				[('u', op.UNDEF)], None, None, [], {}
		])


	def test_07funcall(self):
		tree = self.parser.walk(lambda u: u.lower())
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.CALL, (op.ATTR, (op.VAR, 'u', ns.LOCAL), 'lower'), [], {}, None, None]]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: u.lower(a))
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.CALL, 
					(op.ATTR, (op.VAR, 'u', ns.LOCAL), 'lower'), [(op.VAR, 'a', ns.GLOBAL)], {}, None, None]]],
				[('u', op.UNDEF)], None, None, ['a'], {}
		])

		tree = self.parser.walk(lambda u, v: u.lower(v, 'b', 3))
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.CALL, 
					(op.ATTR, (op.VAR, 'u', ns.LOCAL), 'lower'), 
					[(op.VAR, 'v', ns.LOCAL), (op.CONST, 'b'), (op.CONST, 3)], {}, None, None]]],
				[('u', op.UNDEF), ('v', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u, v: u.lower(v, name='b'))
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.CALL, 
					(op.ATTR, (op.VAR, 'u', ns.LOCAL), 'lower'), 
					[(op.VAR, 'v', ns.LOCAL)], {(op.CONST, 'name'): (op.CONST, 'b')}, None, None]]],
				[('u', op.UNDEF), ('v', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u, v: u.lower(*v, **a))
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, [op.CALL, 
					(op.ATTR, (op.VAR, 'u', ns.LOCAL), 'lower'), [], {}, (op.VAR, 'v', ns.LOCAL), (op.VAR, 'a', ns.GLOBAL)]]],
				[('u', op.UNDEF), ('v', op.UNDEF)], None, None, ['a'], {}
		])


	def test_08string(self):
		tree = self.parser.walk(lambda u: "::" + u)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.ADD, (op.CONST, '::'), (op.VAR, 'u', ns.LOCAL))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: ":: %s" % u)
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.MOD, (op.CONST, ':: %s'), (op.VAR, 'u', ns.LOCAL))]],
				[('u', op.UNDEF)], None, None, [], {}
		])

		tree = self.parser.walk(lambda u: "%s, %d, %s" % (u.name, u.age, "female"))
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.MOD, (op.CONST, '%s, %d, %s'), (op.TUPLE, [ 
					(op.ATTR, (op.VAR, 'u', ns.LOCAL), 'name'),
					(op.ATTR, (op.VAR, 'u', ns.LOCAL), 'age'),
					(op.CONST, 'female')
				]))]],
				[('u', op.UNDEF)], None, None, [], {}
		])
	
	def test_09import(self):
		def func():
			import sys
			import sys as system

			from sys import *
			from sys import stdin, stdout
			from sys import stdin as input, stdout
			from os.path import basename

		tree = self.parser.walk(func)
		self.assertEqual(tree,
			[op.FUNC, 'func', [
				[op.IMPORT, 'sys', []                                    , None    , (op.CONST, -1)],	
				[op.IMPORT, 'sys', []                                    , 'system', (op.CONST, -1)],	
				[op.IMPORT, 'sys', [('*', None)]                         , None    , (op.CONST, -1)],	
				[op.IMPORT, 'sys', [('stdin', None), ('stdout', None)]   , None    , (op.CONST, -1)],	
				[op.IMPORT, 'sys', [('stdin', 'input'), ('stdout', None)], None    , (op.CONST, -1)],	
				[op.IMPORT, 'os.path', [('basename', None)]              , None    , (op.CONST, -1)],	
				[op.RET, (op.CONST, None)]
			], [], None, None, [], {}
		])


	def test_10list(self):
		tree = self.parser.walk(lambda x: x in [1,2])
		self.assertEqual(tree,
			[op.FUNC, op.LAMBDA,
				[[op.RET, (op.IN, (op.VAR, 'x', ns.LOCAL), (op.CONST, (1,2)))]],
				[('x', op.UNDEF)], None, None, [], {}
		])

		def fnc():
			l = [1,2]
			return x in l
		tree = self.parser.walk(fnc)
		self.assertEqual(tree,
			[op.FUNC, 'fnc', [
					(op.SET, (op.VAR, 'l', ns.LOCAL), (op.LIST, [(op.CONST, 1), (op.CONST, 2)])),
					[op.RET, (op.IN, (op.VAR, 'x', ns.GLOBAL), (op.VAR, 'l', ns.LOCAL))]
				], [], None, None, ['x'], {}
		])

	def test_11loop(self):
		def fnc():
			for i in xrange(10):
				if i > 5:
					break
				print i
		tree = self.parser.walk(fnc)
		self.assertEqual(tree,
			[op.FUNC, 'fnc', [
				[op.FOR, (op.VAR, 'i', ns.LOCAL), 
					[op.CALL, (op.VAR, 'xrange', ns.GLOBAL), [(op.CONST, 10)], {}, None, None],
					[
						[op.IF, (op.GT, (op.VAR, 'i', ns.LOCAL), (op.CONST, 5)), [(op.BREAK,)],	[]],
						(op.PRINT, None, [(op.VAR, 'i', ns.LOCAL), (op.CONST, '\n')])
					], None],
				[op.RET, (op.CONST, None)]
			], [], None, None, ['xrange'], {}
		])


	def test_12print(self):
		def printall():
			#NOTE: when python compiler find *print* instructions following each others,
			# it merge it to have only on print call in bytecode 
			# base types, variable, function result
			print 10, (1+2), "pouët", False, a, foo()
			# % operator
			print "%d - %s\n %s" % (24, "Zzzz", True)
			# .format() method
			print "{1} -- {2}".format(a, b)

			# no newline
			z=1 # just to be sure have a new print instruction
			print "blablabla",

			# out stream
			z=1
			print >>myfile, "hoho", 17
			# as output stream is different, should produce a separate print instruction
			print >>otherfile, "bar", u"fôo"

		tree = self.parser.walk(printall)
		self.assertEqual(tree,
			[op.FUNC, 'printall', [
					(op.PRINT, None, [
						# 1st print
						(op.CONST, 10), 
						(op.CONST, 3), 
						(op.CONST, 'pouët'), 
						(op.CONST, False),
						(op.VAR, 'a', ns.GLOBAL),
						[op.CALL, (op.VAR, 'foo', ns.GLOBAL), [], {}, None, None],
						(op.CONST, '\n'),
						# 2d print
						(op.MOD, (op.CONST, "%d - %s\n %s"), (op.TUPLE, [(op.CONST, 24), (op.CONST, "Zzzz"), (op.CONST, True)])),
						(op.CONST, '\n'),
						# 3d print
						[op.CALL, (op.ATTR, (op.CONST, "{1} -- {2}"), 'format'), [(op.VAR, 'a', ns.GLOBAL), (op.VAR, 'b', ns.GLOBAL)], {}, None, None],
						(op.CONST, '\n'),
					]),

					(op.SET, (op.VAR, 'z', ns.LOCAL), (op.CONST, 1)),
					(op.PRINT, None, [(op.CONST, "blablabla")]),

					(op.SET, (op.VAR, 'z', ns.LOCAL), (op.CONST, 1)),
					(op.PRINT, (op.VAR, 'myfile', ns.GLOBAL), [(op.CONST, 'hoho'), (op.CONST, 17), (op.CONST, '\n')]),

					(op.PRINT, (op.VAR, 'otherfile', ns.GLOBAL), [(op.CONST, 'bar'), (op.CONST, u'fôo'), (op.CONST, '\n')]),

					[op.RET, (op.CONST, None)]
				], [], None, None, ['a', 'b', 'foo', 'myfile', 'otherfile'], {}
		])


	def test_13delete(self):
		# delete a variable
		c = False
		def func(b):
			a = 23
			# DELETE_FAST
			del a
			# DELETE_FAST
			del b
			# DELETE_GLOBAL
			global c
			del c
		tree = self.parser.walk(func)
		self.assertEqual(tree,
			[op.FUNC, 'func',
				[(op.SET, (op.VAR, 'a', ns.LOCAL), (op.CONST, 23)),
				 (op.DEL, (op.VAR, 'a', ns.LOCAL)),
				 (op.DEL, (op.VAR, 'b', ns.LOCAL)),
				 (op.DEL, (op.VAR, 'c', ns.GLOBAL)),
				 [op.RET, (op.CONST, None)]
				], [('b', '<undef>')], None, None, ['c'], {}
		])


	def test_14unpackseq(self):
		# simple unpack
		def func():
			global b
			(a, b, c[0]) = (10, 11, 12)
		tree = self.parser.walk(func)
		self.assertEqual(tree, 
			[op.FUNC, 'func',
				[(op.SET, (op.TUPLE, 
					 ((op.VAR, 'a', ns.LOCAL), 
						(op.VAR, 'b', ns.GLOBAL), 
						(op.AT, (op.VAR, 'c', ns.GLOBAL), (op.CONST, 0))
					 )), (op.CONST, (10, 11, 12))),
				 [op.RET, (op.CONST, None)]
				], [], None, None, ['b', 'c'], {}
		])
			# unpack in loop
		def func():
			global b

			l = ((1,2), (3,4))
			for (a, b) in l:
				c = 0
		tree = self.parser.walk(func)
		self.assertEqual(tree,
			[op.FUNC, 'func',
				[(op.SET, (op.VAR, 'l', ns.LOCAL), (op.TUPLE, [(op.CONST, (1,2)), (op.CONST, (3,4))])),
				 [op.FOR, (op.TUPLE, ((op.VAR, 'a', ns.LOCAL), (op.VAR, 'b', ns.GLOBAL))), (op.VAR, 'l', ns.LOCAL),
					 [(op.SET, (op.VAR, 'c', ns.LOCAL), (op.CONST, 0))], None],
				 [op.RET, (op.CONST, None)]
				], [], None, None, ['b'], {}
		])


	def test_15set(self):
		def func():
			foo = 'bar'
			global bis
			bis = 'bille'

			array[42] = 3.14
		tree = self.parser.walk(func)
		self.assertEqual(tree,
			[op.FUNC, 'func',
				[(op.SET, (op.VAR, 'foo', ns.LOCAL) , (op.CONST, 'bar')),
				 (op.SET, (op.VAR, 'bis', ns.GLOBAL), (op.CONST, 'bille')),
				 (op.SET, (op.AT , (op.VAR, 'array', ns.GLOBAL), (op.CONST, 42)), (op.CONST, 3.14)),
				 [op.RET, (op.CONST, None)]
				], [], None, None, ['array', 'bis'], {}
		])

	def test_16try(self):
		#CASE #1: no finally clause, except match all
		def case1():
			try:
				a=1
			except:
				print 'failure'
		tree = self.parser.walk(case1)
		self.assertEqual(tree,
			[op.FUNC, 'case1',
				[[op.TRYCATCH, None, 
					[(op.SET, (op.VAR, 'a', ns.LOCAL), (op.CONST, 1))], 
					[(op.PRINT, None, [(op.CONST, 'failure'), (op.CONST, '\n')])], 
					None],
				 [op.RET, (op.CONST, None)]
				], [], None, None, [], {}
		])


		# CASE #2: except with named exception
		def case2():
			try:
				a=1
			except ValueError:
				print 'failure'

		tree = self.parser.walk(case2)
		self.assertEqual(tree,
			[op.FUNC, 'case2',
				[[op.TRYCATCH,
					((op.VAR, 'ValueError', ns.GLOBAL), None), 
					[(op.SET, (op.VAR, 'a', ns.LOCAL), (op.CONST, 1))], 
					[(op.PRINT, None, [(op.CONST, 'failure'), (op.CONST, '\n')])], 
					None],
				 [op.RET, (op.CONST, None)]
				], [], None, None, ['ValueError'], {}
		])

		# CASE #3: except defined, but without instructions
		#   - except clause must be empty list ([])
		#   - while finally clause must be None
		def case3():
			try:
				a=1
			except ValueError:
				pass

		tree = self.parser.walk(case3)
		self.assertEqual(tree,
			[op.FUNC, 'case3',
				[[op.TRYCATCH,
					((op.VAR, 'ValueError', ns.GLOBAL), None), 
					[(op.SET, (op.VAR, 'a', ns.LOCAL), (op.CONST, 1))], 
					[],
					None],
				 [op.RET, (op.CONST, None)]
				], [], None, None, ['ValueError'], {}
		])

		# CASE #4: except, with exception set in variable
		def case4():
			try:
				a=1
			except ValueError, e:
				print e

		tree = self.parser.walk(case4)
		self.assertEqual(tree,
			[op.FUNC, 'case4',
				[[op.TRYCATCH,
					((op.VAR, 'ValueError', ns.GLOBAL), (op.VAR, 'e', ns.LOCAL)), 
					[(op.SET, (op.VAR, 'a', ns.LOCAL), (op.CONST, 1))], 
					[(op.PRINT, None, [(op.VAR, 'e', ns.LOCAL), (op.CONST, '\n')])], 
					None],
				 [op.RET, (op.CONST, None)]
				], [], None, None, ['ValueError'], {}
		])

		# CASE #5: same as #4, but with global variable
		def case5():
			global e
			try:
				a=1
			except ValueError, e:
				print e