summaryrefslogtreecommitdiffstats
path: root/Lib
diff options
context:
space:
mode:
Diffstat (limited to 'Lib')
-rw-r--r--Lib/SimpleHTTPServer.py3
-rw-r--r--Lib/inspect.py52
-rwxr-xr-xLib/pydoc.py2
-rw-r--r--Lib/test/test_SimpleHTTPServer.py41
-rw-r--r--Lib/test/test_inspect.py28
-rw-r--r--Lib/test/test_mmap.py5
-rw-r--r--Lib/test/test_types.py253
7 files changed, 364 insertions, 20 deletions
diff --git a/Lib/SimpleHTTPServer.py b/Lib/SimpleHTTPServer.py
index a1f25be..eea3243 100644
--- a/Lib/SimpleHTTPServer.py
+++ b/Lib/SimpleHTTPServer.py
@@ -143,7 +143,8 @@ class SimpleHTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
"""
# abandon query parameters
- path = urlparse.urlparse(path)[2]
+ path = path.split('?',1)[0]
+ path = path.split('#',1)[0]
path = posixpath.normpath(urllib.unquote(path))
words = path.split('/')
words = filter(None, words)
diff --git a/Lib/inspect.py b/Lib/inspect.py
index 074754f..ddd7529 100644
--- a/Lib/inspect.py
+++ b/Lib/inspect.py
@@ -7,8 +7,9 @@ It also provides some help for examining source code and class layout.
Here are some of the useful functions provided by this module:
- ismodule(), isclass(), ismethod(), isfunction(), istraceback(),
- isframe(), iscode(), isbuiltin(), isroutine() - check object types
+ ismodule(), isclass(), ismethod(), isfunction(), isgeneratorfunction(),
+ isgenerator(), istraceback(), isframe(), iscode(), isbuiltin(),
+ isroutine() - check object types
getmembers() - get members of an object that satisfy a given condition
getfile(), getsourcefile(), getsource() - find an object's source code
@@ -29,9 +30,20 @@ Here are some of the useful functions provided by this module:
__author__ = 'Ka-Ping Yee <ping@lfw.org>'
__date__ = '1 Jan 2001'
-import sys, os, types, re, dis, imp, tokenize, linecache
+import sys
+import os
+import types
+import string
+import re
+import dis
+import imp
+import tokenize
+import linecache
from operator import attrgetter
from collections import namedtuple
+# These constants are from Include/code.h.
+CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS = 0x1, 0x2, 0x4, 0x8
+CO_NESTED, CO_GENERATOR, CO_NOFREE = 0x10, 0x20, 0x40
# ----------------------------------------------------------- type-checking
def ismodule(object):
@@ -137,6 +149,33 @@ def isfunction(object):
__kwdefaults__ dict of keyword only parameters with defaults"""
return isinstance(object, types.FunctionType)
+def isgeneratorfunction(object):
+ """Return true if the object is a user-defined generator function.
+
+ Generator function objects provides same attributes as functions.
+
+ See isfunction.__doc__ for attributes listing."""
+ if (isfunction(object) or ismethod(object)) and \
+ object.__code__.co_flags & CO_GENERATOR:
+ return True
+
+def isgenerator(object):
+ """Return true if the object is a generator.
+
+ Generator objects provide these attributes:
+ __iter__ defined to support interation over container
+ close raises a new GeneratorExit exception inside the
+ generator to terminate the iteration
+ gi_code code object
+ gi_frame frame object or possibly None once the generator has
+ been exhausted
+ gi_running set to 1 when generator is executing, 0 otherwise
+ next return the next item from the container
+ send resumes the generator and "sends" a value that becomes
+ the result of the current yield-expression
+ throw used to raise an exception inside the generator"""
+ return isinstance(object, types.GeneratorType)
+
def istraceback(object):
"""Return true if the object is a traceback.
@@ -198,6 +237,10 @@ def isroutine(object):
or ismethod(object)
or ismethoddescriptor(object))
+def isgenerator(object):
+ """Return true if the object is a generator object."""
+ return isinstance(object, types.GeneratorType)
+
def getmembers(object, predicate=None):
"""Return all members of an object as (name, value) pairs sorted by name.
Optionally, only return members that satisfy a given predicate."""
@@ -670,9 +713,6 @@ def getclasstree(classes, unique=0):
return walktree(roots, children, None)
# ------------------------------------------------ argument list extraction
-# These constants are from Python's compile.h.
-CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS = 1, 2, 4, 8
-
Arguments = namedtuple('Arguments', 'args, varargs, varkw')
def getargs(co):
diff --git a/Lib/pydoc.py b/Lib/pydoc.py
index c6ec68e..fbad574 100755
--- a/Lib/pydoc.py
+++ b/Lib/pydoc.py
@@ -660,7 +660,7 @@ class HTMLDoc(Doc):
contents = self.multicolumn(
modules, lambda t: self.modulelink(t[1]))
result = result + self.bigsection(
- 'Modules', '#fffff', '#aa55cc', contents)
+ 'Modules', '#ffffff', '#aa55cc', contents)
if classes:
classlist = [value for (key, value) in classes]
diff --git a/Lib/test/test_SimpleHTTPServer.py b/Lib/test/test_SimpleHTTPServer.py
new file mode 100644
index 0000000..9d3ad16
--- /dev/null
+++ b/Lib/test/test_SimpleHTTPServer.py
@@ -0,0 +1,41 @@
+"""
+These tests only check url parsing for now.
+We don't want to require the 'network' resource.
+"""
+
+import os, unittest
+from SimpleHTTPServer import SimpleHTTPRequestHandler
+from test import test_support
+
+
+class SocketlessRequestHandler (SimpleHTTPRequestHandler):
+ def __init__(self):
+ pass
+
+class SimpleHTTPRequestHandlerTestCase(unittest.TestCase):
+ """ Test url parsing """
+ def setUp (self):
+ self.translated = os.getcwd()
+ self.translated = os.path.join(self.translated, 'filename')
+ self.handler = SocketlessRequestHandler ()
+
+ def test_queryArguments (self):
+ path = self.handler.translate_path ('/filename')
+ self.assertEquals (path, self.translated)
+ path = self.handler.translate_path ('/filename?foo=bar')
+ self.assertEquals (path, self.translated)
+ path = self.handler.translate_path ('/filename?a=b&spam=eggs#zot')
+ self.assertEquals (path, self.translated)
+
+ def test_startWithDoubleSlash (self):
+ path = self.handler.translate_path ('//filename')
+ self.assertEquals (path, self.translated)
+ path = self.handler.translate_path ('//filename?foo=bar')
+ self.assertEquals (path, self.translated)
+
+
+def test_main():
+ test_support.run_unittest(SimpleHTTPRequestHandlerTestCase)
+
+if __name__ == "__main__":
+ test_main()
diff --git a/Lib/test/test_inspect.py b/Lib/test/test_inspect.py
index 75e66ed..35a3b06 100644
--- a/Lib/test/test_inspect.py
+++ b/Lib/test/test_inspect.py
@@ -13,10 +13,10 @@ from test import inspect_fodder2 as mod2
# Functions tested in this suite:
# ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode,
-# isbuiltin, isroutine, getmembers, getdoc, getfile, getmodule,
-# getsourcefile, getcomments, getsource, getclasstree, getargspec,
-# getargvalues, formatargspec, formatargvalues, currentframe, stack, trace
-# isdatadescriptor
+# isbuiltin, isroutine, isgenerator, isgeneratorfunction, getmembers,
+# getdoc, getfile, getmodule, getsourcefile, getcomments, getsource,
+# getclasstree, getargspec, getargvalues, formatargspec, formatargvalues,
+# currentframe, stack, trace, isdatadescriptor
modfile = mod.__file__
if modfile.endswith(('c', 'o')):
@@ -41,23 +41,33 @@ git = mod.StupidGit()
class IsTestBase(unittest.TestCase):
predicates = set([inspect.isbuiltin, inspect.isclass, inspect.iscode,
inspect.isframe, inspect.isfunction, inspect.ismethod,
- inspect.ismodule, inspect.istraceback])
+ inspect.ismodule, inspect.istraceback,
+ inspect.isgenerator, inspect.isgeneratorfunction])
def istest(self, predicate, exp):
obj = eval(exp)
self.failUnless(predicate(obj), '%s(%s)' % (predicate.__name__, exp))
for other in self.predicates - set([predicate]):
+ if predicate == inspect.isgeneratorfunction and\
+ other == inspect.isfunction:
+ continue
self.failIf(other(obj), 'not %s(%s)' % (other.__name__, exp))
+def generator_function_example(self):
+ for i in range(2):
+ yield i
+
class TestPredicates(IsTestBase):
- def test_thirteen(self):
+ def test_fifteen(self):
count = len([x for x in dir(inspect) if x.startswith('is')])
- # Doc/lib/libinspect.tex claims there are 13 such functions
- expected = 13
+ # This test is here for remember you to update Doc/library/inspect.rst
+ # which claims there are 15 such functions
+ expected = 15
err_msg = "There are %d (not %d) is* functions" % (count, expected)
self.assertEqual(count, expected, err_msg)
+
def test_excluding_predicates(self):
self.istest(inspect.isbuiltin, 'sys.exit')
self.istest(inspect.isbuiltin, '[].append')
@@ -70,6 +80,8 @@ class TestPredicates(IsTestBase):
self.istest(inspect.ismodule, 'mod')
self.istest(inspect.istraceback, 'tb')
self.istest(inspect.isdatadescriptor, 'collections.defaultdict.default_factory')
+ self.istest(inspect.isgenerator, '(x for x in range(2))')
+ self.istest(inspect.isgeneratorfunction, 'generator_function_example')
if hasattr(types, 'GetSetDescriptorType'):
self.istest(inspect.isgetsetdescriptor,
'type(tb.tb_frame).f_locals')
diff --git a/Lib/test/test_mmap.py b/Lib/test/test_mmap.py
index 08f60f8..fdd75ab 100644
--- a/Lib/test/test_mmap.py
+++ b/Lib/test/test_mmap.py
@@ -435,6 +435,11 @@ class MmapTests(unittest.TestCase):
self.assertRaises(TypeError, m.write, "foo")
+ def test_error(self):
+ self.assert_(issubclass(mmap.error, EnvironmentError))
+ self.assert_("mmap.error" in str(mmap.error))
+
+
def test_main():
run_unittest(MmapTests)
diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
index 0014323..f82fe30 100644
--- a/Lib/test/test_types.py
+++ b/Lib/test/test_types.py
@@ -63,15 +63,15 @@ class TypesTests(unittest.TestCase):
try: 5 / 0
except ZeroDivisionError: pass
- else: self.fail("5 / 0L didn't raise ZeroDivisionError")
+ else: self.fail("5 / 0 didn't raise ZeroDivisionError")
try: 5 // 0
except ZeroDivisionError: pass
- else: self.fail("5 // 0L didn't raise ZeroDivisionError")
+ else: self.fail("5 // 0 didn't raise ZeroDivisionError")
try: 5 % 0
except ZeroDivisionError: pass
- else: self.fail("5 % 0L didn't raise ZeroDivisionError")
+ else: self.fail("5 % 0 didn't raise ZeroDivisionError")
def test_numeric_types(self):
if 0 != 0 or 0 != 0.0 or 0 != 0.0: self.fail('mixed comparisons')
@@ -80,7 +80,7 @@ class TypesTests(unittest.TestCase):
self.fail('int/long/float value not equal')
# calling built-in types without argument must return 0
if int() != 0: self.fail('int() does not return 0')
- if int() != 0: self.fail('long() does not return 0L')
+ if int() != 0: self.fail('long() does not return 0')
if float() != 0.0: self.fail('float() does not return 0.0')
if int(1.9) == 1 == int(1.1) and int(-1.1) == -1 == int(-1.9): pass
else: self.fail('int() does not round properly')
@@ -203,6 +203,251 @@ class TypesTests(unittest.TestCase):
self.assertRaises(TypeError, type, 1, 2)
self.assertRaises(TypeError, type, 1, 2, 3, 4)
+ def test_int__format__(self):
+ def test(i, format_spec, result):
+ # just make sure I'm not accidentally checking longs
+ assert type(i) == int
+ assert type(format_spec) == str
+ self.assertEqual(i.__format__(format_spec), result)
+
+ test(123456789, 'd', '123456789')
+ test(123456789, 'd', '123456789')
+
+ test(1, 'c', '\01')
+
+ # sign and aligning are interdependent
+ test(1, "-", '1')
+ test(-1, "-", '-1')
+ test(1, "-3", ' 1')
+ test(-1, "-3", ' -1')
+ test(1, "+3", ' +1')
+ test(-1, "+3", ' -1')
+ test(1, " 3", ' 1')
+ test(-1, " 3", ' -1')
+ test(1, " ", ' 1')
+ test(-1, " ", '-1')
+
+ # hex
+ test(3, "x", "3")
+ test(3, "X", "3")
+ test(1234, "x", "4d2")
+ test(-1234, "x", "-4d2")
+ test(1234, "8x", " 4d2")
+ test(-1234, "8x", " -4d2")
+ test(1234, "x", "4d2")
+ test(-1234, "x", "-4d2")
+ test(-3, "x", "-3")
+ test(-3, "X", "-3")
+ test(int('be', 16), "x", "be")
+ test(int('be', 16), "X", "BE")
+ test(-int('be', 16), "x", "-be")
+ test(-int('be', 16), "X", "-BE")
+
+ # octal
+ test(3, "o", "3")
+ test(-3, "o", "-3")
+ test(65, "o", "101")
+ test(-65, "o", "-101")
+ test(1234, "o", "2322")
+ test(-1234, "o", "-2322")
+ test(1234, "-o", "2322")
+ test(-1234, "-o", "-2322")
+ test(1234, " o", " 2322")
+ test(-1234, " o", "-2322")
+ test(1234, "+o", "+2322")
+ test(-1234, "+o", "-2322")
+
+ # binary
+ test(3, "b", "11")
+ test(-3, "b", "-11")
+ test(1234, "b", "10011010010")
+ test(-1234, "b", "-10011010010")
+ test(1234, "-b", "10011010010")
+ test(-1234, "-b", "-10011010010")
+ test(1234, " b", " 10011010010")
+ test(-1234, " b", "-10011010010")
+ test(1234, "+b", "+10011010010")
+ test(-1234, "+b", "-10011010010")
+
+ # make sure these are errors
+
+ # precision disallowed
+ self.assertRaises(ValueError, 3 .__format__, "1.3")
+ # sign not allowed with 'c'
+ self.assertRaises(ValueError, 3 .__format__, "+c")
+ # format spec must be string
+ self.assertRaises(TypeError, 3 .__format__, None)
+ self.assertRaises(TypeError, 3 .__format__, 0)
+
+ # ensure that only int and float type specifiers work
+ for format_spec in ([chr(x) for x in range(ord('a'), ord('z')+1)] +
+ [chr(x) for x in range(ord('A'), ord('Z')+1)]):
+ if not format_spec in 'bcdoxXeEfFgGn%':
+ self.assertRaises(ValueError, 0 .__format__, format_spec)
+ self.assertRaises(ValueError, 1 .__format__, format_spec)
+ self.assertRaises(ValueError, (-1) .__format__, format_spec)
+
+ # ensure that float type specifiers work; format converts
+ # the int to a float
+ for format_spec in 'eEfFgGn%':
+ for value in [0, 1, -1, 100, -100, 1234567890, -1234567890]:
+ self.assertEqual(value.__format__(format_spec),
+ float(value).__format__(format_spec))
+
+ def test_long__format__(self):
+ def test(i, format_spec, result):
+ # make sure we're not accidentally checking ints
+ assert type(i) == int
+ assert type(format_spec) == str
+ self.assertEqual(i.__format__(format_spec), result)
+
+ test(10**100, 'd', '1' + '0' * 100)
+ test(10**100+100, 'd', '1' + '0' * 97 + '100')
+
+ test(123456789, 'd', '123456789')
+ test(123456789, 'd', '123456789')
+
+ # sign and aligning are interdependent
+ test(1, "-", '1')
+ test(-1, "-", '-1')
+ test(1, "-3", ' 1')
+ test(-1, "-3", ' -1')
+ test(1, "+3", ' +1')
+ test(-1, "+3", ' -1')
+ test(1, " 3", ' 1')
+ test(-1, " 3", ' -1')
+ test(1, " ", ' 1')
+ test(-1, " ", '-1')
+
+ test(1, 'c', '\01')
+
+ # hex
+ test(3, "x", "3")
+ test(3, "X", "3")
+ test(1234, "x", "4d2")
+ test(-1234, "x", "-4d2")
+ test(1234, "8x", " 4d2")
+ test(-1234, "8x", " -4d2")
+ test(1234, "x", "4d2")
+ test(-1234, "x", "-4d2")
+ test(-3, "x", "-3")
+ test(-3, "X", "-3")
+
+ # octal
+ test(3, "o", "3")
+ test(-3, "o", "-3")
+ test(65, "o", "101")
+ test(-65, "o", "-101")
+ test(1234, "o", "2322")
+ test(-1234, "o", "-2322")
+ test(1234, "-o", "2322")
+ test(-1234, "-o", "-2322")
+ test(1234, " o", " 2322")
+ test(-1234, " o", "-2322")
+ test(1234, "+o", "+2322")
+ test(-1234, "+o", "-2322")
+
+ # binary
+ test(3, "b", "11")
+ test(-3, "b", "-11")
+ test(1234, "b", "10011010010")
+ test(-1234, "b", "-10011010010")
+ test(1234, "-b", "10011010010")
+ test(-1234, "-b", "-10011010010")
+ test(1234, " b", " 10011010010")
+ test(-1234, " b", "-10011010010")
+ test(1234, "+b", "+10011010010")
+ test(-1234, "+b", "-10011010010")
+
+ # make sure these are errors
+
+ # precision disallowed
+ self.assertRaises(ValueError, 3 .__format__, "1.3")
+ # sign not allowed with 'c'
+ self.assertRaises(ValueError, 3 .__format__, "+c")
+ # format spec must be string
+ self.assertRaises(TypeError, 3 .__format__, None)
+ self.assertRaises(TypeError, 3 .__format__, 0)
+
+ # ensure that only int and float type specifiers work
+ for format_spec in ([chr(x) for x in range(ord('a'), ord('z')+1)] +
+ [chr(x) for x in range(ord('A'), ord('Z')+1)]):
+ if not format_spec in 'bcdoxXeEfFgGn%':
+ self.assertRaises(ValueError, 0 .__format__, format_spec)
+ self.assertRaises(ValueError, 1 .__format__, format_spec)
+ self.assertRaises(ValueError, (-1) .__format__, format_spec)
+
+ # ensure that float type specifiers work; format converts
+ # the long to a float
+ for format_spec in 'eEfFgGn%':
+ for value in [0, 1, -1, 100, -100, 1234567890, -1234567890]:
+ self.assertEqual(value.__format__(format_spec),
+ float(value).__format__(format_spec))
+
+ def test_float__format__(self):
+ # these should be rewritten to use both format(x, spec) and
+ # x.__format__(spec)
+
+ def test(f, format_spec, result):
+ assert type(f) == float
+ assert type(format_spec) == str
+ self.assertEqual(f.__format__(format_spec), result)
+
+ test(0.0, 'f', '0.000000')
+
+ # the default is 'g', except for empty format spec
+ test(0.0, '', '0.0')
+ test(0.01, '', '0.01')
+ test(0.01, 'g', '0.01')
+
+ test( 1.0, ' g', ' 1')
+ test(-1.0, ' g', '-1')
+ test( 1.0, '+g', '+1')
+ test(-1.0, '+g', '-1')
+ test(1.1234e200, 'g', '1.1234e+200')
+ test(1.1234e200, 'G', '1.1234E+200')
+
+
+ test(1.0, 'f', '1.000000')
+
+ test(-1.0, 'f', '-1.000000')
+
+ test( 1.0, ' f', ' 1.000000')
+ test(-1.0, ' f', '-1.000000')
+ test( 1.0, '+f', '+1.000000')
+ test(-1.0, '+f', '-1.000000')
+ test(1.1234e200, 'f', '1.1234e+200')
+ test(1.1234e200, 'F', '1.1234e+200')
+
+ # temporarily removed. see issue 1600
+ # test( 1.0, 'e', '1.000000e+00')
+ # test(-1.0, 'e', '-1.000000e+00')
+ # test( 1.0, 'E', '1.000000E+00')
+ # test(-1.0, 'E', '-1.000000E+00')
+ # test(1.1234e20, 'e', '1.123400e+20')
+ # test(1.1234e20, 'E', '1.123400E+20')
+
+ # % formatting
+ test(-1.0, '%', '-100.000000%')
+
+ # format spec must be string
+ self.assertRaises(TypeError, 3.0.__format__, None)
+ self.assertRaises(TypeError, 3.0.__format__, 0)
+
+ # other format specifiers shouldn't work on floats,
+ # in particular int specifiers
+ for format_spec in ([chr(x) for x in range(ord('a'), ord('z')+1)] +
+ [chr(x) for x in range(ord('A'), ord('Z')+1)]):
+ if not format_spec in 'eEfFgGn%':
+ self.assertRaises(ValueError, format, 0.0, format_spec)
+ self.assertRaises(ValueError, format, 1.0, format_spec)
+ self.assertRaises(ValueError, format, -1.0, format_spec)
+ self.assertRaises(ValueError, format, 1e100, format_spec)
+ self.assertRaises(ValueError, format, -1e100, format_spec)
+ self.assertRaises(ValueError, format, 1e-100, format_spec)
+ self.assertRaises(ValueError, format, -1e-100, format_spec)
+
+
def test_main():
run_unittest(TypesTests)
generated by cgit v0.12 at 2025-08-21 07:39:34 (GMT)