Initial revision

2025-08-03 16:39:00 +00:00 · 1992-01-27 17:00:37 +00:00 · 1992-01-27 17:00:37 +00:00 · 3bead0984c
commit 3bead0984c
parent 19a86e72df
9 changed files with 913 additions and 0 deletions
--- a/Lib/pdb.doc
+++ b/Lib/pdb.doc
@ -0,0 +1,157 @@
+The Python Debugger
+===================
+
+To use the debugger in its simplest form:
+
+	>>> import pdb
+	>>> pdb.run('<a statement>')
+
+The debugger's prompt is '(Pdb) '.  This will stop in the first
+function call in <a statement>.
+
+The commands recognized by the debugger are listed in the next
+section.  Most can be abbreviated as indicated; e.g., h(elp) means
+that 'help' can be typed as 'h' or 'help' (but not as 'he' or 'hel',
+nor as 'H' or 'Help' or 'HELP').  Optional arguments are enclosed in
+square brackets.
+
+A blank line repeats the previous command literally.  (Except for
+'list', where it lists the next 11 lines.)
+
+Commands that the debugger doesn't recognize are assumed to be Python
+statements and are executed in the context of the program being
+debugged.  Python statements can also be prefixed with an exclamation
+point ('!').  This is a powerful way to inspect the program being
+debugged; it is even possible to change variables.  When an exception
+occurs in such a statement, the exception name is printed but the
+debugger's state is not changed.
+
+The debugger is not directly programmable; but it is implemented as a
+class from which you can derive your own debugger class, so you can
+make as fancy as you like.
+
+
+Debugger commands
+=================
+
+h(elp)
+	Without argument, print the list of available commands.
+	With a command name as argument, print help about that command
+	(this is currently not implemented).
+
+w(here)
+	Print a stack trace, with the most recent frame at the bottom.
+	An arrow indicates the "current frame", which determines the
+	context of most commands.
+
+d(own)
+	Move the current frame one level down in the stack trace
+	(to an older frame).
+
+u(p)
+	Move the current frame one level up in the stack trace
+	(to a newer frame).
+
+b(reak) [lineno]
+	With a line number argument, set a break there in the current file.
+	Without argument, list all breaks.
+
+cl(ear) [lineno]
+	With a line number argument, clear that break in the current file.
+	Without argument, clear all breaks (but first ask confirmation).
+
+s(tep)
+	Execute the current line, stop at the first possible occasion
+	(either in a function that is called or in the current function).
+
+n(ext)
+	Continue execution until the next line in the current function
+	is reached or it returns.
+
+r(eturn)
+	Continue execution until the current function returns.
+
+c(ont(inue))
+	Continue execution, only stop when a breakpoint is encountered.
+
+l(ist) [first [,last]]
+	List source code for the current file.
+	Without arguments, list 11 lines around the current line
+	or continue the previous listing.
+	With one argument, list 11 lines starting at that line.
+	With two arguments, list the given range;
+	if the second argument is less than the first, it is a count.
+
+a(rgs)
+	Print the argument list of the current function.
+
+p expression
+	Print the value of the expression.
+
+(!) statement
+	Execute the (one-line) statement in the context of
+	the current stack frame.
+	The exclamation point can be omitted unless the first word
+	of the statement resembles a debugger command.
+	To assign to a global variable you must always prefix the
+	command with a 'global' command, e.g.:
+	(Pdb) global list_options; list_options = ['-l']
+	(Pdb)
+
+q(uit)
+	Quit from the debugger.
+	The program being executed is aborted.
+
+
+How it works
+============
+
+Some changes were made to the interpreter:
+- if sys.trace is defined (by the user) and not None, it should be a function
+- sys.trace is called the global trace function
+- there can also a local trace function (see later)
+
+Trace functions have three arguments: (frame, event, arg)
+  - frame is the current stack frame
+  - event is a string: 'call', 'line', 'return' or 'exception'
+  - arg is dependent on the event type
+A trace function should return a new trace function or None.
+Class methods are accepted (and most useful!) as trace methods.
+
+The events have the following meaning:
+
+  'call':      A function is called (or some other code block entered).
+               The global trace function is called;
+               arg is the argument list to the function;
+               the return value specifies the local trace function.
+
+  'line':      The interpreter is about to execute a new line of code
+               (sometimes multiple line events on one line exist).
+               The local trace function is called; arg in None;
+               the return value specifies the new local trace function.
+
+  'return':    A function (or other code block) is about to return.
+               The local trace function is called;
+               arg is the value that will be returned.
+               The trace function's return value is ignored.
+
+  'exception': An exception has occurred.
+               The local trace function is called;
+               arg is a triple (exception, value, traceback);
+               the return value specifies the new local trace function
+
+Note that as an exception is propagated down the chain of callers, an
+'exception' event is generated at each level.
+
+Stack frame objects have the following read-only attributes:
+  f_code:      the code object being executed
+  f_lineno:    the current line number (-1 for 'call' events)
+  f_back:      the stack frame of the caller, or None
+  f_locals:    dictionary containing local name bindings
+  f_globals:   dictionary containing global name bindings
+
+Code objects have the following read-only attributes:
+  co_code:     the code string
+  co_names:    the list of names used by the code
+  co_consts:   the list of (literal) constants used by the code
+  co_filename: the filename from which the code was compiled
--- a/Lib/test/test_b1.py
+++ b/Lib/test/test_b1.py
@ -0,0 +1,127 @@
+# Python test set -- part 4a, built-in functions a-m
+
+from test_support import *
+
+print 'abs'
+if abs(0) <> 0: raise TestFailed, 'abs(0)'
+if abs(1234) <> 1234: raise TestFailed, 'abs(1234)'
+if abs(-1234) <> 1234: raise TestFailed, 'abs(-1234)'
+#
+if abs(0.0) <> 0.0: raise TestFailed, 'abs(0.0)'
+if abs(3.14) <> 3.14: raise TestFailed, 'abs(3.14)'
+if abs(-3.14) <> 3.14: raise TestFailed, 'abs(-3.14)'
+#
+if abs(0L) <> 0L: raise TestFailed, 'abs(0L)'
+if abs(1234L) <> 1234L: raise TestFailed, 'abs(1234L)'
+if abs(-1234L) <> 1234L: raise TestFailed, 'abs(-1234L)'
+
+print 'apply'
+def f0(*args):
+	if args != (): raise TestFailed, 'f0 called with ' + `args`
+def f1(a1):
+	if a1 != 1: raise TestFailed, 'f1 called with ' + `a1`
+def f2(a1, a2):
+	if a1 != 1 or a2 != 2:
+		raise TestFailed, 'f2 called with ' + `a1, a2`
+def f3(a1, a2, a3):
+	if a1 != 1 or a2 != 2 or a3 != 3:
+		raise TestFailed, 'f2 called with ' + `a1, a2, a3`
+apply(f0, ())
+apply(f1, (1,))
+apply(f2, (1, 2))
+apply(f3, (1, 2, 3))
+
+print 'chr'
+if chr(32) <> ' ': raise TestFailed, 'chr(32)'
+if chr(65) <> 'A': raise TestFailed, 'chr(65)'
+if chr(97) <> 'a': raise TestFailed, 'chr(97)'
+
+print 'dir'
+x = 1
+if 'x' not in dir(): raise TestFailed, 'dir()'
+import sys
+if 'modules' not in dir(sys): raise TestFailed, 'dir(sys)'
+
+print 'divmod'
+if divmod(12, 7) <> (1, 5): raise TestFailed, 'divmod(12, 7)'
+if divmod(-12, 7) <> (-2, 2): raise TestFailed, 'divmod(-12, 7)'
+if divmod(12, -7) <> (-2, -2): raise TestFailed, 'divmod(12, -7)'
+if divmod(-12, -7) <> (1, -5): raise TestFailed, 'divmod(-12, -7)'
+#
+if divmod(12L, 7L) <> (1L, 5L): raise TestFailed, 'divmod(12L, 7L)'
+if divmod(-12L, 7L) <> (-2L, 2L): raise TestFailed, 'divmod(-12L, 7L)'
+if divmod(12L, -7L) <> (-2L, -2L): raise TestFailed, 'divmod(12L, -7L)'
+if divmod(-12L, -7L) <> (1L, -5L): raise TestFailed, 'divmod(-12L, -7L)'
+#
+if divmod(12, 7L) <> (1, 5L): raise TestFailed, 'divmod(12, 7L)'
+if divmod(-12, 7L) <> (-2, 2L): raise TestFailed, 'divmod(-12, 7L)'
+if divmod(12L, -7) <> (-2L, -2): raise TestFailed, 'divmod(12L, -7)'
+if divmod(-12L, -7) <> (1L, -5): raise TestFailed, 'divmod(-12L, -7)'
+#
+if divmod(3.25, 1.0) <> (3.0, 0.25): raise TestFailed, 'divmod(3.25, 1.0)'
+if divmod(-3.25, 1.0) <> (-4.0, 0.75): raise TestFailed, 'divmod(-3.25, 1.0)'
+if divmod(3.25, -1.0) <> (-4.0, -0.75): raise TestFailed, 'divmod(3.25, -1.0)'
+if divmod(-3.25, -1.0) <> (3.0, -0.25): raise TestFailed, 'divmod(-3.25, -1.0)'
+
+print 'eval'
+if eval('1+1') <> 2: raise TestFailed, 'eval(\'1+1\')'
+
+print 'exec'
+z = 0
+exec('z=1+1\n')
+if z <> 2: raise TestFailed, 'exec(\'z=1+1\'\\n)'
+
+print 'float'
+if float(3.14) <> 3.14: raise TestFailed, 'float(3.14)'
+if float(314) <> 314.0: raise TestFailed, 'float(314)'
+if float(314L) <> 314.0: raise TestFailed, 'float(314L)'
+
+print 'getattr'
+import sys
+if getattr(sys, 'stdout') is not sys.stdout: raise TestFailed, 'getattr'
+
+print 'hex'
+if hex(16) != '0x10': raise TestFailed, 'hex(16)'
+if hex(16L) != '0x10L': raise TestFailed, 'hex(16L)'
+if hex(-16) != '-0x10': raise TestFailed, 'hex(-16)'
+if hex(-16L) != '-0x10L': raise TestFailed, 'hex(-16L)'
+
+# Test input() later, together with raw_input
+
+print 'int'
+if int(314) <> 314: raise TestFailed, 'int(314)'
+if int(3.14) <> 3: raise TestFailed, 'int(3.14)'
+if int(314L) <> 314: raise TestFailed, 'int(314L)'
+
+print 'len'
+if len('123') <> 3: raise TestFailed, 'len(\'123\')'
+if len(()) <> 0: raise TestFailed, 'len(())'
+if len((1, 2, 3, 4)) <> 4: raise TestFailed, 'len((1, 2, 3, 4))'
+if len([1, 2, 3, 4]) <> 4: raise TestFailed, 'len([1, 2, 3, 4])'
+if len({}) <> 0: raise TestFailed, 'len({})'
+if len({'a':1, 'b': 2}) <> 2: raise TestFailed, 'len({\'a\':1, \'b\': 2})'
+
+print 'long'
+if long(314) <> 314L: raise TestFailed, 'long(314)'
+if long(3.14) <> 3L: raise TestFailed, 'long(3.14)'
+if long(314L) <> 314L: raise TestFailed, 'long(314L)'
+
+print 'max'
+if max('123123') <> '3': raise TestFailed, 'max(\'123123\')'
+if max(1, 2, 3) <> 3: raise TestFailed, 'max(1, 2, 3)'
+if max((1, 2, 3, 1, 2, 3)) <> 3: raise TestFailed, 'max((1, 2, 3, 1, 2, 3))'
+if max([1, 2, 3, 1, 2, 3]) <> 3: raise TestFailed, 'max([1, 2, 3, 1, 2, 3])'
+#
+if max(1, 2L, 3.0) <> 3.0: raise TestFailed, 'max(1, 2L, 3.0)'
+if max(1L, 2.0, 3) <> 3: raise TestFailed, 'max(1L, 2.0, 3)'
+if max(1.0, 2, 3L) <> 3L: raise TestFailed, 'max(1.0, 2, 3L)'
+
+print 'min'
+if min('123123') <> '1': raise TestFailed, 'min(\'123123\')'
+if min(1, 2, 3) <> 1: raise TestFailed, 'min(1, 2, 3)'
+if min((1, 2, 3, 1, 2, 3)) <> 1: raise TestFailed, 'min((1, 2, 3, 1, 2, 3))'
+if min([1, 2, 3, 1, 2, 3]) <> 1: raise TestFailed, 'min([1, 2, 3, 1, 2, 3])'
+#
+if min(1, 2L, 3.0) <> 1: raise TestFailed, 'min(1, 2L, 3.0)'
+if min(1L, 2.0, 3) <> 1L: raise TestFailed, 'min(1L, 2.0, 3)'
+if min(1.0, 2, 3L) <> 1.0: raise TestFailed, 'min(1.0, 2, 3L)'
--- a/Lib/test/test_b2.py
+++ b/Lib/test/test_b2.py
@ -0,0 +1,130 @@
+# Python test set -- part 4b, built-in functions n-z
+
+from test_support import *
+
+print 'oct'
+if oct(100) != '0144': raise TestFailed, 'oct(100)'
+if oct(100L) != '0144L': raise TestFailed, 'oct(100L)'
+if oct(-100) != '-0144': raise TestFailed, 'oct(-100)'
+if oct(-100L) != '-0144L': raise TestFailed, 'oct(-100L)'
+
+print 'open'
+# NB the first 4 lines are also used to test input and raw_input, below
+fp = open(TESTFN, 'w')
+try:
+	fp.write('1+1\n')
+	fp.write('1+1\n')
+	fp.write('The quick brown fox jumps over the lazy dog')
+	fp.write('.\n')
+	fp.write('Dear John\n')
+	fp.write('XXX'*100)
+	fp.write('YYY'*100)
+finally:
+	fp.close()
+#
+fp = open(TESTFN, 'r')
+try:
+	if fp.readline(4) <> '1+1\n': raise TestFailed, 'readline(4) # exact'
+	if fp.readline(4) <> '1+1\n': raise TestFailed, 'readline(4) # exact'
+	if fp.readline() <> 'The quick brown fox jumps over the lazy dog.\n':
+		raise TestFailed, 'readline() # default'
+	if fp.readline(4) <> 'Dear': raise TestFailed, 'readline(4) # short'
+	if fp.readline(100) <> ' John\n': raise TestFailed, 'readline(100)'
+	if fp.read(300) <> 'XXX'*100: raise TestFailed, 'read(300)'
+	if fp.read(1000) <> 'YYY'*100: raise TestFailed, 'read(1000) # truncate'
+finally:
+	fp.close()
+
+print 'ord'
+if ord(' ') <> 32: raise TestFailed, 'ord(\' \')'
+if ord('A') <> 65: raise TestFailed, 'ord(\'A\')'
+if ord('a') <> 97: raise TestFailed, 'ord(\'a\')'
+
+print 'pow'
+if pow(0,0) <> 1: raise TestFailed, 'pow(0,0)'
+if pow(0,1) <> 0: raise TestFailed, 'pow(0,1)'
+if pow(1,0) <> 1: raise TestFailed, 'pow(1,0)'
+if pow(1,1) <> 1: raise TestFailed, 'pow(1,1)'
+#
+if pow(2,0) <> 1: raise TestFailed, 'pow(2,0)'
+if pow(2,10) <> 1024: raise TestFailed, 'pow(2,10)'
+if pow(2,20) <> 1024*1024: raise TestFailed, 'pow(2,20)'
+if pow(2,30) <> 1024*1024*1024: raise TestFailed, 'pow(2,30)'
+#
+if pow(-2,0) <> 1: raise TestFailed, 'pow(-2,0)'
+if pow(-2,1) <> -2: raise TestFailed, 'pow(-2,1)'
+if pow(-2,2) <> 4: raise TestFailed, 'pow(-2,2)'
+if pow(-2,3) <> -8: raise TestFailed, 'pow(-2,3)'
+#
+if pow(0L,0) <> 1: raise TestFailed, 'pow(0L,0)'
+if pow(0L,1) <> 0: raise TestFailed, 'pow(0L,1)'
+if pow(1L,0) <> 1: raise TestFailed, 'pow(1L,0)'
+if pow(1L,1) <> 1: raise TestFailed, 'pow(1L,1)'
+#
+if pow(2L,0) <> 1: raise TestFailed, 'pow(2L,0)'
+if pow(2L,10) <> 1024: raise TestFailed, 'pow(2L,10)'
+if pow(2L,20) <> 1024*1024: raise TestFailed, 'pow(2L,20)'
+if pow(2L,30) <> 1024*1024*1024: raise TestFailed, 'pow(2L,30)'
+#
+if pow(-2L,0) <> 1: raise TestFailed, 'pow(-2L,0)'
+if pow(-2L,1) <> -2: raise TestFailed, 'pow(-2L,1)'
+if pow(-2L,2) <> 4: raise TestFailed, 'pow(-2L,2)'
+if pow(-2L,3) <> -8: raise TestFailed, 'pow(-2L,3)'
+#
+if pow(0.,0) <> 1.: raise TestFailed, 'pow(0.,0)'
+if pow(0.,1) <> 0.: raise TestFailed, 'pow(0.,1)'
+if pow(1.,0) <> 1.: raise TestFailed, 'pow(1.,0)'
+if pow(1.,1) <> 1.: raise TestFailed, 'pow(1.,1)'
+#
+if pow(2.,0) <> 1.: raise TestFailed, 'pow(2.,0)'
+if pow(2.,10) <> 1024.: raise TestFailed, 'pow(2.,10)'
+if pow(2.,20) <> 1024.*1024.: raise TestFailed, 'pow(2.,20)'
+if pow(2.,30) <> 1024.*1024.*1024.: raise TestFailed, 'pow(2.,30)'
+#
+# XXX These don't work -- negative float to the float power...
+#if pow(-2.,0) <> 1.: raise TestFailed, 'pow(-2.,0)'
+#if pow(-2.,1) <> -2.: raise TestFailed, 'pow(-2.,1)'
+#if pow(-2.,2) <> 4.: raise TestFailed, 'pow(-2.,2)'
+#if pow(-2.,3) <> -8.: raise TestFailed, 'pow(-2.,3)'
+
+print 'range'
+if range(3) <> [0, 1, 2]: raise TestFailed, 'range(3)'
+if range(1, 5) <> [1, 2, 3, 4]: raise TestFailed, 'range(1, 5)'
+if range(0) <> []: raise TestFailed, 'range(0)'
+if range(-3) <> []: raise TestFailed, 'range(-3)'
+if range(1, 10, 3) <> [1, 4, 7]: raise TestFailed, 'range(1, 10, 3)'
+if range(5, -5, -3) <> [5, 2, -1, -4]: raise TestFailed, 'range(5, -5, -3)'
+
+print 'input and raw_input'
+import sys
+fp = open(TESTFN, 'r')
+savestdin = sys.stdin
+try:
+	sys.stdin = fp
+	if input() <> 2: raise TestFailed, 'input()'
+	if input('testing\n') <> 2: raise TestFailed, 'input()'
+	if raw_input() <> 'The quick brown fox jumps over the lazy dog.':
+		raise TestFailed, 'raw_input()'
+	if raw_input('testing\n') <> 'Dear John':
+		raise TestFailed, 'raw_input(\'testing\\n\')'
+finally:
+	sys.stdin = savestdin
+	fp.close()
+
+print 'reload'
+import string
+reload(string)
+
+print 'setattr'
+import sys
+setattr(sys, 'foobar', 1)
+if sys.foobar != 1: raise TestFailed, 'setattr(sys, \'foobar\', 1)'
+
+print 'type'
+if type('') <> type('123') or type('') == type(()):
+	raise TestFailed, 'type()'
+
+
+# Epilogue -- unlink the temp file
+
+unlink(TESTFN)
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@ -0,0 +1,13 @@
+# Python test set -- part 4, built-in functions
+
+from test_support import *
+
+print '4. Built-in functions'
+
+print 'test_b1'
+unload('test_b1')
+import test_b1
+
+print 'test_b2'
+unload('test_b2')
+import test_b2
--- a/Lib/test/test_exceptions.py
+++ b/Lib/test/test_exceptions.py
@ -0,0 +1,91 @@
+# Python test set -- part 5, built-in exceptions
+
+from test_support import *
+
+print '5. Built-in exceptions'
+# XXX This is not really enough, each *operation* should be tested!
+
+def r(name): print name
+
+r(AttributeError)
+import sys
+try: x = sys.undefined_attribute
+except AttributeError: pass
+
+r(EOFError)
+import sys
+fp = open(TESTFN, 'w')
+fp.close()
+fp = open(TESTFN, 'r')
+savestdin = sys.stdin
+try:
+	sys.stdin = fp
+	x = raw_input()
+except EOFError:
+	pass
+finally:
+	sys.stdin = savestdin
+	fp.close()
+
+r(IOError)
+try: open('this file does not exist', 'r')
+except IOError: pass
+
+r(ImportError)
+try: import undefined_module
+except ImportError: pass
+
+r(IndexError)
+x = []
+try: a = x[10]
+except IndexError: pass
+
+r(KeyError)
+x = {}
+try: a = x['key']
+except KeyError: pass
+
+r(KeyboardInterrupt)
+print '(not testable in a script)'
+
+r(MemoryError)
+print '(not safe to test)'
+
+r(NameError)
+try: x = undefined_variable
+except NameError: pass
+
+r(OverflowError)
+x = 1
+try:
+	while 1: x = x+x
+except OverflowError: pass
+
+r(RuntimeError)
+print '(not used any more?)'
+
+r(SyntaxError)
+try: exec('/\n')
+except SyntaxError: pass
+
+r(SystemError)
+print '(hard to reproduce)'
+
+r(SystemExit)
+import sys
+try: sys.exit(0)
+except SystemExit: pass
+
+r(TypeError)
+try: [] + ()
+except TypeError: pass
+
+r(ValueError)
+try: x = chr(10000)
+except ValueError: pass
+
+r(ZeroDivisionError)
+try: x = 1/0
+except ZeroDivisionError: pass
+
+unlink(TESTFN)
--- a/Lib/test/test_grammar.py
+++ b/Lib/test/test_grammar.py
@ -0,0 +1,344 @@
+# Python test set -- part 1, grammar.
+# This just tests whether the parser accepts them all.
+
+from test_support import *
+
+print '1. Parser'
+
+print '1.1 Tokens'
+
+print '1.1.1 Backslashes'
+
+# Backslash means line continuation:
+x = 1 \
+ 1
+if x <> 2: raise TestFailed, 'backslash for line continuation'
+
+# Backslash does not means continuation in comments :\
+x = 0
+if x <> 0: raise TestFailed, 'backslash ending comment'
+
+print '1.1.2 Numeric literals'
+
+print '1.1.2.1 Plain integers'
+if 0xff <> 255: raise TestFailed, 'hex int'
+if 0377 <> 255: raise TestFailed, 'octal int'
+if  2147483647   != 017777777777: raise TestFailed, 'max positive int'
+if -2147483647-1 != 020000000000: raise TestFailed, 'max negative int'
+# XXX -2147483648
+if 037777777777 != -1: raise TestFailed, 'oct -1'
+if 0xffffffff != -1: raise TestFailed, 'hex -1'
+for s in '2147483648', '040000000000', '0x100000000':
+	try:
+		x = eval(s)
+	except OverflowError:
+		continue
+	raise TestFailed, 'No OverflowError on huge integer literal ' + `s`
+
+print '1.1.2.2 Long integers'
+x = 0L
+x = 0l
+x = 0xffffffffffffffffL
+x = 0xffffffffffffffffl
+x = 077777777777777777L
+x = 077777777777777777l
+x = 123456789012345678901234567890L
+x = 123456789012345678901234567890l
+
+print '1.1.2.3 Floating point'
+x = 3.14
+x = 314.
+x = 0.314
+# XXX x = 000.314
+x = .314
+x = 3e14
+x = 3E14
+x = 3e-14
+x = 3e+14
+x = 3.e14
+x = .3e14
+x = 3.1e4
+
+print '1.2 Grammar'
+
+print 'single_input' # NEWLINE | simple_stmt | compound_stmt NEWLINE
+# XXX can't test in a script -- this rule is only used when interactive
+
+print 'file_input' # (NEWLINE | stmt)* ENDMARKER
+# Being tested as this very moment this very module
+
+print 'expr_input' # testlist NEWLINE
+# XXX Hard to test -- used only in calls to input()
+
+print 'eval_input' # testlist ENDMARKER
+x = eval('1, 0 or 1')
+
+print 'funcdef'
+### 'def' NAME parameters ':' suite
+### parameters: '(' [varargslist] ')'
+### varargslist: (fpdef ',')* ('+'|'*') NAME | fpdef (',' fpdef)* [',']
+### fpdef: NAME | '(' fplist ')'
+### fplist: fpdef (',' fpdef)* [',']
+def f1(): pass
+def f2(one_argument): pass
+def f3(two, arguments): pass
+def f4(two, (compound, (argument, list))): pass
+def a1(one_arg,): pass
+def a2(two, args,): pass
+def v0(*rest): pass
+def v1(a, *rest): pass
+def v2(a, b, *rest): pass
+def v3(a, (b, c), *rest): pass
+
+### stmt: simple_stmt | compound_stmt
+# Tested below
+
+### simple_stmt: small_stmt (';' small_stmt)* [';']
+print 'simple_stmt'
+x = 1; pass; del x
+
+### small_stmt: expr_stmt | print_stmt  | pass_stmt | del_stmt | flow_stmt | import_stmt
+# Tested below
+
+print 'expr_stmt' # (exprlist '=')* exprlist
+1
+1, 2, 3
+x = 1
+x = 1, 2, 3
+x = y = z = 1, 2, 3
+x, y, z = 1, 2, 3
+abc = a, b, c = x, y, z = xyz = 1, 2, (3, 4)
+# NB these variables are deleted below
+
+print 'print_stmt' # 'print' (test ',')* [test]
+print 1, 2, 3
+print 1, 2, 3,
+print
+print 0 or 1, 0 or 1,
+print 0 or 1
+
+print 'del_stmt' # 'del' exprlist
+del abc
+del x, y, (z, xyz)
+
+print 'pass_stmt' # 'pass'
+pass
+
+print 'flow_stmt' # break_stmt | continue_stmt | return_stmt | raise_stmt
+# Tested below
+
+print 'break_stmt' # 'break'
+while 1: break
+
+print 'continue_stmt' # 'continue'
+i = 1
+while i: i = 0; continue
+
+print 'return_stmt' # 'return' [testlist]
+def g1(): return
+def g2(): return 1
+g1()
+x = g2()
+
+print 'raise_stmt' # 'raise' test [',' test]
+try: raise RuntimeError, 'just testing'
+except RuntimeError: pass
+try: raise KeyboardInterrupt
+except KeyboardInterrupt: pass
+
+print 'import_stmt' # 'import' NAME (',' NAME)* | 'from' NAME 'import' ('*' | NAME (',' NAME)*)
+[1]
+import sys
+[2]
+import time, math
+[3]
+from time import sleep
+[4]
+from sys import *
+[5]
+from math import sin, cos
+[6]
+
+print 'global_stmt' # 'global' NAME (',' NAME)*
+def f():
+	global a
+	global a, b
+	global one, two, three, four, five, six, seven, eight, nine, ten
+
+### compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | funcdef | classdef
+# Tested below
+
+print 'if_stmt' # 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
+if 1: pass
+if 1: pass
+else: pass
+if 0: pass
+elif 0: pass
+if 0: pass
+elif 0: pass
+elif 0: pass
+elif 0: pass
+else: pass
+
+print 'while_stmt' # 'while' test ':' suite ['else' ':' suite]
+while 0: pass
+while 0: pass
+else: pass
+
+print 'for_stmt' # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite]
+[1]
+for i in 1, 2, 3: pass
+[2]
+for i, j, k in (): pass
+else: pass
+[3]
+
+print 'try_stmt' # 'try' ':' suite (except_clause ':' suite)* ['finally' ':' suite]
+### except_clause: 'except' [expr [',' expr]]
+try: pass
+try: 1/0
+except ZeroDivisionError: pass
+try: 1/0
+except EOFError: pass
+except TypeError, msg: pass
+except RuntimeError, msg: pass
+except: pass
+try: pass
+finally: pass
+try: 1/0
+except: pass
+finally: pass
+
+print 'suite' # simple_stmt | NEWLINE INDENT NEWLINE* (stmt NEWLINE*)+ DEDENT
+if 1: pass
+if 1:
+	pass
+if 1:
+	#
+	#
+	#
+	pass
+	pass
+	#
+	pass
+	#
+
+print 'test'
+### and_test ('or' and_test)*
+### and_test: not_test ('and' not_test)*
+### not_test: 'not' not_test | comparison
+if not 1: pass
+if 1 and 1: pass
+if 1 or 1: pass
+if not not not 1: pass
+if not 1 and 1 and 1: pass
+if 1 and 1 or 1 and 1 and 1 or not 1 and 1: pass
+
+print 'comparison'
+### comparison: expr (comp_op expr)*
+### comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not'
+if 1: pass
+x = (1 == 1)
+if 1 == 1: pass
+if 1 != 1: pass
+if 1 <> 1: pass
+if 1 < 1: pass
+if 1 > 1: pass
+if 1 <= 1: pass
+if 1 >= 1: pass
+if 1 is 1: pass
+if 1 is not 1: pass
+if 1 in (): pass
+if 1 not in (): pass
+if 1 < 1 > 1 == 1 >= 1 <= 1 <> 1 in 1 not in 1 is 1 is not 1: pass
+
+print 'binary mask ops'
+x = 1 & 1
+x = 1 ^ 1
+x = 1 | 1
+
+print 'shift ops'
+x = 1 << 1
+x = 1 >> 1
+x = 1 << 1 >> 1
+
+print 'additive ops'
+x = 1
+x = 1 + 1
+x = 1 - 1 - 1
+x = 1 - 1 + 1 - 1 + 1
+
+print 'multiplicative ops'
+x = 1 * 1
+x = 1 / 1
+x = 1 % 1
+x = 1 / 1 * 1 % 1
+
+print 'unary ops'
+x = +1
+x = -1
+x = ~1
+x = ~1 ^ 1 & 1 | 1 & 1 ^ -1
+x = -1*1/1 + 1*1 - ---1*1
+
+print 'selectors'
+### trailer: '(' [testlist] ')' | '[' subscript ']' | '.' NAME
+### subscript: expr | [expr] ':' [expr]
+import sys, time
+c = sys.path[0]
+x = time.time()
+x = sys.modules['time'].time()
+a = '01234'
+c = a[0]
+c = a[-1]
+s = a[0:5]
+s = a[:5]
+s = a[0:]
+s = a[:]
+s = a[-5:]
+s = a[:-1]
+s = a[-4:-3]
+
+print 'atoms'
+### atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictmaker] '}' | '`' testlist '`' | NAME | NUMBER | STRING
+### dictmaker: test ':' test (',' test ':' test)* [',']
+
+x = (1)
+x = (1 or 2 or 3)
+x = (1 or 2 or 3, 2, 3)
+
+x = []
+x = [1]
+x = [1 or 2 or 3]
+x = [1 or 2 or 3, 2, 3]
+x = []
+
+x = {}
+x = {'one': 1}
+x = {'one': 1,}
+x = {'one' or 'two': 1 or 2}
+x = {'one': 1, 'two': 2}
+x = {'one': 1, 'two': 2,}
+x = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}
+
+x = `x`
+x = `1 or 2 or 3`
+x = x
+x = 'x'
+x = 123
+
+### exprlist: expr (',' expr)* [',']
+### testlist: test (',' test)* [',']
+# These have been exercised enough above
+
+print 'classdef' # 'class' NAME parameters ['=' baselist] ':' suite
+### baselist: atom arguments (',' atom arguments)*
+### arguments: '(' [testlist] ')'
+class B: pass
+class C1(B): pass
+class C2(B): pass
+class D(C1, C2, B): pass
+class C:
+	def meth1(self): pass
+	def meth2(self, arg): pass
+	def meth3(self, a1, a2): pass
--- a/Lib/test/test_opcodes.py
+++ b/Lib/test/test_opcodes.py
@ -0,0 +1,24 @@
+# Python test set -- part 2, opcodes
+
+from test_support import *
+
+
+print '2. Opcodes'
+print 'XXX Not yet fully implemented'
+
+print '2.1 try inside for loop'
+n = 0
+for i in range(10):
+	n = n+i
+	try: 1/0
+	except NameError: pass
+	except ZeroDivisionError: pass
+	except TypeError: pass
+	finally: pass
+	try: pass
+	except: pass
+	try: pass
+	finally: pass
+	n = n+i
+if n <> 90:
+	raise TestFailed, 'try inside for'
--- a/Lib/test/test_operations.py
+++ b/Lib/test/test_operations.py
@ -0,0 +1,5 @@
+# Python test set -- part 3, built-in operations.
+
+
+print '3. Operations'
+print 'XXX Not yet implemented'
--- a/Lib/test/test_support.py
+++ b/Lib/test/test_support.py
@ -0,0 +1,22 @@
+# Python test set -- supporting definitions.
+
+TestFailed = 'test_support -- test failed'	# Exception
+
+def unload(name):
+	import sys
+	try:
+		del sys.modules[name]
+	except KeyError:
+		pass
+
+def forget(modname):
+	unload(modname)
+	import sys, os
+	for dirname in sys.path:
+		try:
+			os.unlink(os.path.join(dirname, modname + '.pyc'))
+		except os.error:
+			pass
+
+TESTFN = '@test' # Filename used for testing
+from os import unlink