From jython-checkins at python.org Wed Nov 2 00:26:36 2011 From: jython-checkins at python.org (philip.jenvey) Date: Wed, 02 Nov 2011 00:26:36 +0100 Subject: [Jython-checkins] =?utf8?q?jython_=282=2E5=29=3A_closed_the_mista?= =?utf8?q?ken_duplicate_of_the_2=2E5_branch?= Message-ID: http://hg.python.org/jython/rev/ba82edbd3598 changeset: 6262:ba82edbd3598 branch: 2.5 parent: 6260:936bd1b132eb user: Philip Jenvey date: Tue Nov 01 16:06:16 2011 -0700 summary: closed the mistaken duplicate of the 2.5 branch files: -- Repository URL: http://hg.python.org/jython From jython-checkins at python.org Wed Nov 2 00:26:36 2011 From: jython-checkins at python.org (philip.jenvey) Date: Wed, 02 Nov 2011 00:26:36 +0100 Subject: [Jython-checkins] =?utf8?q?jython_=282=2E5=29=3A_Fix_for_some_min?= =?utf8?q?or_socket_issues_relating_to_attributes=2E?= Message-ID: http://hg.python.org/jython/rev/e93cb387ae49 changeset: 6263:e93cb387ae49 branch: 2.5 parent: 6256:700d0f7c35db user: Alan Kennedy date: Sat Oct 29 18:49:09 2011 +0100 summary: Fix for some minor socket issues relating to attributes. http://bugs.jython.org/issue1803 http://bugs.jython.org/issue1804 (transplanted from be3145efdbb1236f94d6227187312cf00e43b963) files: Lib/socket.py | 18 +++++++++++++----- Lib/test/test_socket.py | 17 ++++++++++++----- 2 files changed, 25 insertions(+), 10 deletions(-) diff --git a/Lib/socket.py b/Lib/socket.py --- a/Lib/socket.py +++ b/Lib/socket.py @@ -581,17 +581,25 @@ return None return Protocol.getProtocolByName(protocol_name).getProto() -def _realsocket(family = AF_INET, type = SOCK_STREAM, protocol=0): +def _realsocket(family = AF_INET, sock_type = SOCK_STREAM, protocol=0): assert family in (AF_INET, AF_INET6), "Only AF_INET and AF_INET6 sockets are currently supported on jython" - assert type in (SOCK_DGRAM, SOCK_STREAM), "Only SOCK_STREAM and SOCK_DGRAM sockets are currently supported on jython" - if type == SOCK_STREAM: + assert sock_type in (SOCK_DGRAM, SOCK_STREAM), "Only SOCK_STREAM and SOCK_DGRAM sockets are currently supported on jython" + if sock_type == SOCK_STREAM: if protocol != 0: assert protocol == IPPROTO_TCP, "Only IPPROTO_TCP supported on SOCK_STREAM sockets" - return _tcpsocket() + else: + protocol = IPPROTO_TCP + result = _tcpsocket() else: if protocol != 0: assert protocol == IPPROTO_UDP, "Only IPPROTO_UDP supported on SOCK_DGRAM sockets" - return _udpsocket() + else: + protocol = IPPROTO_UDP + result = _udpsocket() + setattr(result, "family", family) + setattr(result, "type", sock_type) + setattr(result, "proto", protocol) + return result # # Attempt to provide IDNA (RFC 3490) support. diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py --- a/Lib/test/test_socket.py +++ b/Lib/test/test_socket.py @@ -27,11 +27,6 @@ is_bsd = os_name == 'Mac OS X' or 'BSD' in os_name is_solaris = os_name == 'SunOS' -try: - True -except NameError: - True, False = 1, 0 - class SocketTCPTest(unittest.TestCase): HOST = HOST @@ -491,6 +486,18 @@ name = sock.getsockname() self.assertEqual(name, ("0.0.0.0", PORT+1)) + def testSockAttributes(self): + # Testing required attributes + for family in [socket.AF_INET, socket.AF_INET6]: + for sock_type in [socket.SOCK_STREAM, socket.SOCK_DGRAM]: + s = socket.socket(family, sock_type) + self.assertEqual(s.family, family) + self.assertEqual(s.type, sock_type) + if sock_type == socket.SOCK_STREAM: + self.assertEqual(s.proto, socket.IPPROTO_TCP) + else: + self.assertEqual(s.proto, socket.IPPROTO_UDP) + def testGetSockOpt(self): # Testing getsockopt() # We know a socket should start without reuse==0 -- Repository URL: http://hg.python.org/jython From jython-checkins at python.org Wed Nov 2 00:26:36 2011 From: jython-checkins at python.org (philip.jenvey) Date: Wed, 02 Nov 2011 00:26:36 +0100 Subject: [Jython-checkins] =?utf8?q?jython_=282=2E5=29=3A_Fix_for_xml_attr?= =?utf8?q?ibute_namespaces_issue?= Message-ID: http://hg.python.org/jython/rev/0ba48ac4ed54 changeset: 6264:0ba48ac4ed54 branch: 2.5 user: Alan Kennedy date: Sun Oct 30 13:07:20 2011 +0000 summary: Fix for xml attribute namespaces issue http://bugs.jython.org/issue1768 (transplanted from 936bd1b132eb9c591cf915b060c6567ae8e16914) files: Lib/test/test_sax.py | 46 ++++++++-------- Lib/xml/sax/drivers2/drv_javasax.py | 2 +- NEWS | 3 + 3 files changed, 28 insertions(+), 23 deletions(-) diff --git a/Lib/test/test_sax.py b/Lib/test/test_sax.py --- a/Lib/test/test_sax.py +++ b/Lib/test/test_sax.py @@ -390,22 +390,23 @@ gather = AttrGatherer() parser.setContentHandler(gather) - parser.parse(StringIO("" % ns_uri)) + a_name = "id" ; a_val = "val" + parser.parse(StringIO("" % (ns_uri, a_name, a_val) )) attrs = gather._attrs return attrs.getLength() == 1 and \ - attrs.getNames() == [(ns_uri, "attr")] and \ - attrs.getQNames() == ["ns:attr"] and \ + attrs.getNames() == [(ns_uri, a_name)] and \ + attrs.getQNames() == ["ns:%s" % a_name] and \ len(attrs) == 1 and \ - attrs.has_key((ns_uri, "attr")) and \ - attrs.keys() == [(ns_uri, "attr")] and \ - attrs.get((ns_uri, "attr")) == "val" and \ - attrs.get((ns_uri, "attr"), 25) == "val" and \ - attrs.items() == [((ns_uri, "attr"), "val")] and \ - attrs.values() == ["val"] and \ - attrs.getValue((ns_uri, "attr")) == "val" and \ - attrs[(ns_uri, "attr")] == "val" + attrs.has_key((ns_uri, a_name)) and \ + attrs.keys() == [(ns_uri, a_name)] and \ + attrs.get((ns_uri, a_name)) == a_val and \ + attrs.get((ns_uri, a_name), 25) == a_val and \ + attrs.items() == [((ns_uri, a_name), a_val)] and \ + attrs.values() == [a_val] and \ + attrs.getValue((ns_uri, a_name)) == a_val and \ + attrs[(ns_uri, a_name)] == a_val def test_expat_nsattrs_no_namespace(): parser = make_parser() @@ -413,22 +414,23 @@ gather = AttrGatherer() parser.setContentHandler(gather) - parser.parse(StringIO("")) + a_name = "id" ; a_val = "val" + parser.parse(StringIO("" % (a_name, a_val) )) attrs = gather._attrs return attrs.getLength() == 1 and \ - attrs.getNames() == [(None, "attr")] and \ - attrs.getQNames() == ["attr"] and \ + attrs.getNames() == [(None, a_name)] and \ + attrs.getQNames() == [a_name] and \ len(attrs) == 1 and \ - attrs.has_key((None, "attr")) and \ - attrs.keys() == [(None, "attr")] and \ - attrs.get((None, "attr")) == "val" and \ - attrs.get((None, "attr"), 25) == "val" and \ - attrs.items() == [((None, "attr"), "val")] and \ - attrs.values() == ["val"] and \ - attrs.getValue((None, "attr")) == "val" and \ - attrs[(None, "attr")] == "val" + attrs.has_key((None, a_name)) and \ + attrs.keys() == [(None, a_name)] and \ + attrs.get((None, a_name)) == a_val and \ + attrs.get((None, a_name), 25) == a_val and \ + attrs.items() == [((None, a_name), a_val)] and \ + attrs.values() == [a_val] and \ + attrs.getValue((None, a_name)) == a_val and \ + attrs[(None, a_name)] == a_val # ===== InputSource support diff --git a/Lib/xml/sax/drivers2/drv_javasax.py b/Lib/xml/sax/drivers2/drv_javasax.py --- a/Lib/xml/sax/drivers2/drv_javasax.py +++ b/Lib/xml/sax/drivers2/drv_javasax.py @@ -238,7 +238,7 @@ pass # TODO def _fixTuple(nsTuple, frm, to): - if len(nsTuple) == 2: + if isinstance(nsTuple, tuple) and len(nsTuple) == 2: nsUri, localName = nsTuple if nsUri == frm: nsUri = to diff --git a/NEWS b/NEWS --- a/NEWS +++ b/NEWS @@ -5,6 +5,9 @@ - [ 1727 ] Error in Jython 2.5.2 with os.stat and varargs - [ 1735 ] return type of os.read is unicode, not str - [ 1755 ] os.utime('/tmp/nonexistent-file', None) fails to raise OSError + - [ 1768 ] sax.parse doesn't handle attributes with name 'id' correctly + - [ 1803 ] _tcpsocket doesn't have 'family' attribute + - [ 1804 ] _tcpsocket doesn't have 'type' and 'proto' attributes - [ 1811 ] Recursive import bug w/ SQLAlchemy 0.7.3 Jython 2.5.2 -- Repository URL: http://hg.python.org/jython From jython-checkins at python.org Wed Nov 2 00:26:36 2011 From: jython-checkins at python.org (philip.jenvey) Date: Wed, 02 Nov 2011 00:26:36 +0100 Subject: [Jython-checkins] =?utf8?q?jython_=28merge_2=2E5_-=3E_default=29?= =?utf8?q?=3A_merge_with_2=2E5?= Message-ID: http://hg.python.org/jython/rev/1651fbbecffd changeset: 6265:1651fbbecffd parent: 6261:179cb4437158 parent: 6264:0ba48ac4ed54 user: Philip Jenvey date: Tue Nov 01 16:15:59 2011 -0700 summary: merge with 2.5 files: -- Repository URL: http://hg.python.org/jython From jython-checkins at python.org Wed Nov 2 01:32:32 2011 From: jython-checkins at python.org (alan.kennedy) Date: Wed, 02 Nov 2011 01:32:32 +0100 Subject: [Jython-checkins] =?utf8?q?jython_=282=2E5=29=3A_Fixing_the_getad?= =?utf8?q?drinfo_API_to_be_closer_to_the_C_API=2E?= Message-ID: http://hg.python.org/jython/rev/7306b9651a3a changeset: 6266:7306b9651a3a branch: 2.5 parent: 6264:0ba48ac4ed54 user: Alan Kennedy date: Wed Nov 02 00:27:42 2011 +0000 summary: Fixing the getaddrinfo API to be closer to the C API. Fixes http://bugs.jython.org/issue1809 files: Lib/socket.py | 71 ++++++++++++++++---- Lib/test/test_socket.py | 95 ++++++++++++++++++++++++++++- 2 files changed, 149 insertions(+), 17 deletions(-) diff --git a/Lib/socket.py b/Lib/socket.py --- a/Lib/socket.py +++ b/Lib/socket.py @@ -1,5 +1,5 @@ """ -This is an updated socket module for use on JVMs > 1.5; it is derived from the old jython socket module. +This is an updated socket module for use on JVMs >= 1.5; it is derived from the old jython socket module. It is documented, along with known issues and workarounds, on the jython wiki. http://wiki.python.org/jython/NewSocketModule """ @@ -174,11 +174,19 @@ SHUT_RDWR = 2 AF_UNSPEC = 0 -AF_INET = 2 -AF_INET6 = 23 +AF_INET = 2 +AF_INET6 = 23 -AI_PASSIVE=1 -AI_CANONNAME=2 +AI_PASSIVE = 1 +AI_CANONNAME = 2 +AI_NUMERICHOST = 4 +AI_V4MAPPED = 8 +AI_ALL = 16 +AI_ADDRCONFIG = 32 +AI_NUMERICSERV = 1024 + +EAI_NONAME = -2 +EAI_SERVICE = -8 # For some reason, probably historical, SOCK_DGRAM and SOCK_STREAM are opposite values of what they are on cpython. # I.E. The following is the way they are on cpython @@ -565,21 +573,30 @@ from jnr.netdb import Service except ImportError: return None - return Service.getServiceByName(service_name, protocol_name).getPort() + service = Service.getServiceByName(service_name, protocol_name) + if service is None: + raise error('service/proto not found') + return service.getPort() def getservbyport(port, protocol_name=None): try: from jnr.netdb import Service except ImportError: return None - return Service.getServiceByPort(port, protocol_name).getName() + service = Service.getServiceByPort(port, protocol_name) + if service is None: + raise error('port/proto not found') + return service.getName() def getprotobyname(protocol_name=None): try: from jnr.netdb import Protocol except ImportError: return None - return Protocol.getProtocolByName(protocol_name).getProto() + proto = Protocol.getProtocolByName(protocol_name) + if proto is None: + raise error('protocol not found') + return proto.getProto() def _realsocket(family = AF_INET, sock_type = SOCK_STREAM, protocol=0): assert family in (AF_INET, AF_INET6), "Only AF_INET and AF_INET6 sockets are currently supported on jython" @@ -723,19 +740,39 @@ global _ipv4_addresses_only _ipv4_addresses_only = value +def _get_port_number(port, flags): + if isinstance(port, basestring): + try: + int_port = int(port) + except ValueError: + if flags and flags & AI_NUMERICSERV: + raise gaierror(EAI_NONAME, "Name or service not known") + # Lookup the service by name + try: + int_port = getservbyname(port) + except error: + raise gaierror(EAI_SERVICE, "Servname not supported for ai_socktype") + elif port is None: + int_port = 0 + elif not isinstance(port, (int, long)): + raise error("Int or String expected") + else: + int_port = int(port) + return int_port % 65536 + def getaddrinfo(host, port, family=AF_INET, socktype=None, proto=0, flags=None): try: + if _ipv4_addresses_only: + family = AF_INET if not family in [AF_INET, AF_INET6, AF_UNSPEC]: raise gaierror(errno.EIO, 'ai_family not supported') + port = _get_port_number(port, flags) filter_fns = [] - if _ipv4_addresses_only: - filter_fns.append( lambda x: isinstance(x, java.net.Inet4Address) ) - else: - filter_fns.append({ - AF_INET: lambda x: isinstance(x, java.net.Inet4Address), - AF_INET6: lambda x: isinstance(x, java.net.Inet6Address), - AF_UNSPEC: lambda x: isinstance(x, java.net.InetAddress), - }[family]) + filter_fns.append({ + AF_INET: lambda x: isinstance(x, java.net.Inet4Address), + AF_INET6: lambda x: isinstance(x, java.net.Inet6Address), + AF_UNSPEC: lambda x: isinstance(x, java.net.InetAddress), + }[family]) if host == "": host = java.net.InetAddress.getLocalHost().getHostName() if isinstance(host, unicode): @@ -793,6 +830,7 @@ def ntohl(x): return x def inet_pton(family, ip_string): + # FIXME: java.net.InetAddress.getByName also accepts hostnames try: ia = java.net.InetAddress.getByName(ip_string) bytes = [] @@ -1514,6 +1552,7 @@ raise StopIteration return line +_GLOBAL_DEFAULT_TIMEOUT = object() # Define the SSL support diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py --- a/Lib/test/test_socket.py +++ b/Lib/test/test_socket.py @@ -379,6 +379,39 @@ if udpport is not None: eq(socket.getservbyport(udpport, 'udp'), service) + def testGetServByExceptions(self): + # First getservbyname + try: + result = socket.getservbyname("nosuchservice") + except socket.error: + pass + except Exception, x: + self.fail("getservbyname raised wrong exception for non-existent service: %s" % str(x)) + else: + self.fail("getservbyname failed to raise exception for non-existent service: %s" % str(result)) + + # Now getservbyport + try: + result = socket.getservbyport(55555) + except socket.error: + pass + except Exception, x: + self.fail("getservbyport raised wrong exception for unknown port: %s" % str(x)) + else: + self.fail("getservbyport failed to raise exception for unknown port: %s" % str(result)) + + def testGetProtoByName(self): + self.failUnlessEqual(socket.IPPROTO_TCP, socket.getprotobyname("tcp")) + self.failUnlessEqual(socket.IPPROTO_UDP, socket.getprotobyname("udp")) + try: + result = socket.getprotobyname("nosuchproto") + except socket.error: + pass + except Exception, x: + self.fail("getprotobyname raised wrong exception for unknown protocol: %s" % str(x)) + else: + self.fail("getprotobyname failed to raise exception for unknown protocol: %s" % str(result)) + def testDefaultTimeout(self): # Testing default timeout # The default timeout should initially be None @@ -1537,6 +1570,66 @@ self.failUnless(str(ipv6_address_tuple) in ["('::1', 80, 0, 0)", "('0:0:0:0:0:0:0:1', 80, 0, 0)"]) self.failUnless(repr(ipv6_address_tuple) in ["('::1', 80, 0, 0)", "('0:0:0:0:0:0:0:1', 80, 0, 0)"]) + def testNonIntPort(self): + hostname = "localhost" + + # Port value of None should map to 0 + addrs = socket.getaddrinfo(hostname, None) + for a in addrs: + self.failUnlessEqual(a[4][1], 0, "Port value of None should have returned 0") + + # Port value can be a string rep of the port number + addrs = socket.getaddrinfo(hostname, "80") + for a in addrs: + self.failUnlessEqual(a[4][1], 80, "Port value of '80' should have returned 80") + + # Can also specify a service name + # This test assumes that service http will always be at port 80 + addrs = socket.getaddrinfo(hostname, "http") + for a in addrs: + self.failUnlessEqual(a[4][1], 80, "Port value of 'http' should have returned 80") + + # Check treatment of non-integer numeric port + try: + socket.getaddrinfo(hostname, 79.99) + except socket.error, se: + self.failUnlessEqual(se[0], "Int or String expected") + except Exception, x: + self.fail("getaddrinfo for float port number raised wrong exception: %s" % str(x)) + else: + self.fail("getaddrinfo for float port number failed to raise exception") + + # Check treatment of non-integer numeric port, as a string + # The result is that it should fail in the same way as a non-existent service + try: + socket.getaddrinfo(hostname, "79.99") + except socket.gaierror, g: + self.failUnlessEqual(g[0], socket.EAI_SERVICE) + except Exception, x: + self.fail("getaddrinfo for non-integer numeric port, as a string raised wrong exception: %s" % str(x)) + else: + self.fail("getaddrinfo for non-integer numeric port, as a string failed to raise exception") + + # Check enforcement of AI_NUMERICSERV + try: + socket.getaddrinfo(hostname, "http", 0, 0, 0, socket.AI_NUMERICSERV) + except socket.gaierror, g: + self.failUnlessEqual(g[0], socket.EAI_NONAME) + except Exception, x: + self.fail("getaddrinfo for service name with AI_NUMERICSERV raised wrong exception: %s" % str(x)) + else: + self.fail("getaddrinfo for service name with AI_NUMERICSERV failed to raise exception") + + # Check treatment of non-existent service + try: + socket.getaddrinfo(hostname, "nosuchservice") + except socket.gaierror, g: + self.failUnlessEqual(g[0], socket.EAI_SERVICE) + except Exception, x: + self.fail("getaddrinfo for unknown service name raised wrong exception: %s" % str(x)) + else: + self.fail("getaddrinfo for unknown service name failed to raise exception") + class TestJython_get_jsockaddr(unittest.TestCase): "These tests are specific to jython: they test a key internal routine" @@ -1863,7 +1956,7 @@ if False: tests.append(UDPBroadcastTest) suites = [unittest.makeSuite(klass, 'test') for klass in tests] - test_support.run_suite(unittest.TestSuite(suites)) + test_support._run_suite(unittest.TestSuite(suites)) if __name__ == "__main__": test_main() -- Repository URL: http://hg.python.org/jython From jython-checkins at python.org Wed Nov 2 01:32:32 2011 From: jython-checkins at python.org (alan.kennedy) Date: Wed, 02 Nov 2011 01:32:32 +0100 Subject: [Jython-checkins] =?utf8?q?jython_=28merge_2=2E5_-=3E_default=29?= =?utf8?q?=3A_merge_with_2=2E5=3A_Fixing_the_getaddrinfo_API_to_be_closer_?= =?utf8?q?to_the_C_API=2E?= Message-ID: http://hg.python.org/jython/rev/95a08a9556f0 changeset: 6267:95a08a9556f0 parent: 6265:1651fbbecffd parent: 6266:7306b9651a3a user: Alan Kennedy date: Wed Nov 02 00:31:05 2011 +0000 summary: merge with 2.5: Fixing the getaddrinfo API to be closer to the C API. Fixes http://bugs.jython.org/issue1809 files: Lib/socket.py | 70 ++++++++++++++++---- Lib/test/test_socket.py | 93 +++++++++++++++++++++++++++++ 2 files changed, 147 insertions(+), 16 deletions(-) diff --git a/Lib/socket.py b/Lib/socket.py --- a/Lib/socket.py +++ b/Lib/socket.py @@ -1,5 +1,5 @@ """ -This is an updated socket module for use on JVMs > 1.5; it is derived from the old jython socket module. +This is an updated socket module for use on JVMs >= 1.5; it is derived from the old jython socket module. It is documented, along with known issues and workarounds, on the jython wiki. http://wiki.python.org/jython/NewSocketModule """ @@ -174,11 +174,19 @@ SHUT_RDWR = 2 AF_UNSPEC = 0 -AF_INET = 2 -AF_INET6 = 23 +AF_INET = 2 +AF_INET6 = 23 -AI_PASSIVE=1 -AI_CANONNAME=2 +AI_PASSIVE = 1 +AI_CANONNAME = 2 +AI_NUMERICHOST = 4 +AI_V4MAPPED = 8 +AI_ALL = 16 +AI_ADDRCONFIG = 32 +AI_NUMERICSERV = 1024 + +EAI_NONAME = -2 +EAI_SERVICE = -8 # For some reason, probably historical, SOCK_DGRAM and SOCK_STREAM are opposite values of what they are on cpython. # I.E. The following is the way they are on cpython @@ -565,21 +573,30 @@ from jnr.netdb import Service except ImportError: return None - return Service.getServiceByName(service_name, protocol_name).getPort() + service = Service.getServiceByName(service_name, protocol_name) + if service is None: + raise error('service/proto not found') + return service.getPort() def getservbyport(port, protocol_name=None): try: from jnr.netdb import Service except ImportError: return None - return Service.getServiceByPort(port, protocol_name).getName() + service = Service.getServiceByPort(port, protocol_name) + if service is None: + raise error('port/proto not found') + return service.getName() def getprotobyname(protocol_name=None): try: from jnr.netdb import Protocol except ImportError: return None - return Protocol.getProtocolByName(protocol_name).getProto() + proto = Protocol.getProtocolByName(protocol_name) + if proto is None: + raise error('protocol not found') + return proto.getProto() def _realsocket(family = AF_INET, sock_type = SOCK_STREAM, protocol=0): assert family in (AF_INET, AF_INET6), "Only AF_INET and AF_INET6 sockets are currently supported on jython" @@ -723,19 +740,39 @@ global _ipv4_addresses_only _ipv4_addresses_only = value +def _get_port_number(port, flags): + if isinstance(port, basestring): + try: + int_port = int(port) + except ValueError: + if flags and flags & AI_NUMERICSERV: + raise gaierror(EAI_NONAME, "Name or service not known") + # Lookup the service by name + try: + int_port = getservbyname(port) + except error: + raise gaierror(EAI_SERVICE, "Servname not supported for ai_socktype") + elif port is None: + int_port = 0 + elif not isinstance(port, (int, long)): + raise error("Int or String expected") + else: + int_port = int(port) + return int_port % 65536 + def getaddrinfo(host, port, family=AF_INET, socktype=None, proto=0, flags=None): try: + if _ipv4_addresses_only: + family = AF_INET if not family in [AF_INET, AF_INET6, AF_UNSPEC]: raise gaierror(errno.EIO, 'ai_family not supported') + port = _get_port_number(port, flags) filter_fns = [] - if _ipv4_addresses_only: - filter_fns.append( lambda x: isinstance(x, java.net.Inet4Address) ) - else: - filter_fns.append({ - AF_INET: lambda x: isinstance(x, java.net.Inet4Address), - AF_INET6: lambda x: isinstance(x, java.net.Inet6Address), - AF_UNSPEC: lambda x: isinstance(x, java.net.InetAddress), - }[family]) + filter_fns.append({ + AF_INET: lambda x: isinstance(x, java.net.Inet4Address), + AF_INET6: lambda x: isinstance(x, java.net.Inet6Address), + AF_UNSPEC: lambda x: isinstance(x, java.net.InetAddress), + }[family]) if host == "": host = java.net.InetAddress.getLocalHost().getHostName() if isinstance(host, unicode): @@ -793,6 +830,7 @@ def ntohl(x): return x def inet_pton(family, ip_string): + # FIXME: java.net.InetAddress.getByName also accepts hostnames try: ia = java.net.InetAddress.getByName(ip_string) bytes = [] diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py --- a/Lib/test/test_socket.py +++ b/Lib/test/test_socket.py @@ -379,6 +379,39 @@ if udpport is not None: eq(socket.getservbyport(udpport, 'udp'), service) + def testGetServByExceptions(self): + # First getservbyname + try: + result = socket.getservbyname("nosuchservice") + except socket.error: + pass + except Exception, x: + self.fail("getservbyname raised wrong exception for non-existent service: %s" % str(x)) + else: + self.fail("getservbyname failed to raise exception for non-existent service: %s" % str(result)) + + # Now getservbyport + try: + result = socket.getservbyport(55555) + except socket.error: + pass + except Exception, x: + self.fail("getservbyport raised wrong exception for unknown port: %s" % str(x)) + else: + self.fail("getservbyport failed to raise exception for unknown port: %s" % str(result)) + + def testGetProtoByName(self): + self.failUnlessEqual(socket.IPPROTO_TCP, socket.getprotobyname("tcp")) + self.failUnlessEqual(socket.IPPROTO_UDP, socket.getprotobyname("udp")) + try: + result = socket.getprotobyname("nosuchproto") + except socket.error: + pass + except Exception, x: + self.fail("getprotobyname raised wrong exception for unknown protocol: %s" % str(x)) + else: + self.fail("getprotobyname failed to raise exception for unknown protocol: %s" % str(result)) + def testDefaultTimeout(self): # Testing default timeout # The default timeout should initially be None @@ -1537,6 +1570,66 @@ self.failUnless(str(ipv6_address_tuple) in ["('::1', 80, 0, 0)", "('0:0:0:0:0:0:0:1', 80, 0, 0)"]) self.failUnless(repr(ipv6_address_tuple) in ["('::1', 80, 0, 0)", "('0:0:0:0:0:0:0:1', 80, 0, 0)"]) + def testNonIntPort(self): + hostname = "localhost" + + # Port value of None should map to 0 + addrs = socket.getaddrinfo(hostname, None) + for a in addrs: + self.failUnlessEqual(a[4][1], 0, "Port value of None should have returned 0") + + # Port value can be a string rep of the port number + addrs = socket.getaddrinfo(hostname, "80") + for a in addrs: + self.failUnlessEqual(a[4][1], 80, "Port value of '80' should have returned 80") + + # Can also specify a service name + # This test assumes that service http will always be at port 80 + addrs = socket.getaddrinfo(hostname, "http") + for a in addrs: + self.failUnlessEqual(a[4][1], 80, "Port value of 'http' should have returned 80") + + # Check treatment of non-integer numeric port + try: + socket.getaddrinfo(hostname, 79.99) + except socket.error, se: + self.failUnlessEqual(se[0], "Int or String expected") + except Exception, x: + self.fail("getaddrinfo for float port number raised wrong exception: %s" % str(x)) + else: + self.fail("getaddrinfo for float port number failed to raise exception") + + # Check treatment of non-integer numeric port, as a string + # The result is that it should fail in the same way as a non-existent service + try: + socket.getaddrinfo(hostname, "79.99") + except socket.gaierror, g: + self.failUnlessEqual(g[0], socket.EAI_SERVICE) + except Exception, x: + self.fail("getaddrinfo for non-integer numeric port, as a string raised wrong exception: %s" % str(x)) + else: + self.fail("getaddrinfo for non-integer numeric port, as a string failed to raise exception") + + # Check enforcement of AI_NUMERICSERV + try: + socket.getaddrinfo(hostname, "http", 0, 0, 0, socket.AI_NUMERICSERV) + except socket.gaierror, g: + self.failUnlessEqual(g[0], socket.EAI_NONAME) + except Exception, x: + self.fail("getaddrinfo for service name with AI_NUMERICSERV raised wrong exception: %s" % str(x)) + else: + self.fail("getaddrinfo for service name with AI_NUMERICSERV failed to raise exception") + + # Check treatment of non-existent service + try: + socket.getaddrinfo(hostname, "nosuchservice") + except socket.gaierror, g: + self.failUnlessEqual(g[0], socket.EAI_SERVICE) + except Exception, x: + self.fail("getaddrinfo for unknown service name raised wrong exception: %s" % str(x)) + else: + self.fail("getaddrinfo for unknown service name failed to raise exception") + class TestJython_get_jsockaddr(unittest.TestCase): "These tests are specific to jython: they test a key internal routine" -- Repository URL: http://hg.python.org/jython From jython-checkins at python.org Wed Nov 2 01:50:09 2011 From: jython-checkins at python.org (alan.kennedy) Date: Wed, 02 Nov 2011 01:50:09 +0100 Subject: [Jython-checkins] =?utf8?q?jython_=282=2E5=29=3A_Updating_NEWS_fi?= =?utf8?q?le_with_a_bug_fix_notice=2E?= Message-ID: http://hg.python.org/jython/rev/826ec962e0c1 changeset: 6268:826ec962e0c1 branch: 2.5 parent: 6266:7306b9651a3a user: Alan Kennedy date: Wed Nov 02 00:45:16 2011 +0000 summary: Updating NEWS file with a bug fix notice. files: NEWS | 1 + 1 files changed, 1 insertions(+), 0 deletions(-) diff --git a/NEWS b/NEWS --- a/NEWS +++ b/NEWS @@ -8,6 +8,7 @@ - [ 1768 ] sax.parse doesn't handle attributes with name 'id' correctly - [ 1803 ] _tcpsocket doesn't have 'family' attribute - [ 1804 ] _tcpsocket doesn't have 'type' and 'proto' attributes + - [ 1809 ] socket.getaddrinfo sometimes returns an object that crashes in __str__ - [ 1811 ] Recursive import bug w/ SQLAlchemy 0.7.3 Jython 2.5.2 -- Repository URL: http://hg.python.org/jython From jython-checkins at python.org Wed Nov 2 01:50:09 2011 From: jython-checkins at python.org (alan.kennedy) Date: Wed, 02 Nov 2011 01:50:09 +0100 Subject: [Jython-checkins] =?utf8?q?jython_=28merge_2=2E5_-=3E_default=29?= =?utf8?q?=3A_merge_with_2=2E5=3A_Updating_NEWS_file_with_a_bug_fix_notice?= =?utf8?q?=2E?= Message-ID: http://hg.python.org/jython/rev/386860c0254c changeset: 6269:386860c0254c parent: 6267:95a08a9556f0 parent: 6268:826ec962e0c1 user: Alan Kennedy date: Wed Nov 02 00:48:43 2011 +0000 summary: merge with 2.5: Updating NEWS file with a bug fix notice. files: NEWS | 1 + 1 files changed, 1 insertions(+), 0 deletions(-) diff --git a/NEWS b/NEWS --- a/NEWS +++ b/NEWS @@ -8,6 +8,7 @@ - [ 1768 ] sax.parse doesn't handle attributes with name 'id' correctly - [ 1803 ] _tcpsocket doesn't have 'family' attribute - [ 1804 ] _tcpsocket doesn't have 'type' and 'proto' attributes + - [ 1809 ] socket.getaddrinfo sometimes returns an object that crashes in __str__ - [ 1811 ] Recursive import bug w/ SQLAlchemy 0.7.3 Jython 2.5.2 -- Repository URL: http://hg.python.org/jython From jython-checkins at python.org Wed Nov 2 10:47:50 2011 From: jython-checkins at python.org (alan.kennedy) Date: Wed, 02 Nov 2011 10:47:50 +0100 Subject: [Jython-checkins] =?utf8?q?jython_=282=2E5=29=3A_Introducing_sock?= =?utf8?q?et=2Ecreate=5Fconnection=2E?= Message-ID: http://hg.python.org/jython/rev/cc548bacc001 changeset: 6270:cc548bacc001 branch: 2.5 parent: 6268:826ec962e0c1 user: Alan Kennedy date: Wed Nov 02 09:43:30 2011 +0000 summary: Introducing socket.create_connection. This is required for 2.6, but is also a useful convenience method for 2.5 users. Fixes http://bugs.jython.org/issue1788 files: Lib/socket.py | 29 +++++++++++++++++++++++++++++ 1 files changed, 29 insertions(+), 0 deletions(-) diff --git a/Lib/socket.py b/Lib/socket.py --- a/Lib/socket.py +++ b/Lib/socket.py @@ -1554,6 +1554,35 @@ _GLOBAL_DEFAULT_TIMEOUT = object() +def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT): + """Connect to *address* and return the socket object. + + Convenience function. Connect to *address* (a 2-tuple ``(host, + port)``) and return the socket object. Passing the optional + *timeout* parameter will set the timeout on the socket instance + before attempting to connect. If no *timeout* is supplied, the + global default timeout setting returned by :func:`getdefaulttimeout` + is used. + """ + + msg = "getaddrinfo returns an empty list" + host, port = address + for res in getaddrinfo(host, port, 0, SOCK_STREAM): + af, socktype, proto, canonname, sa = res + sock = None + try: + sock = socket(af, socktype, proto) + if timeout is not _GLOBAL_DEFAULT_TIMEOUT: + sock.settimeout(timeout) + sock.connect(sa) + return sock + + except error, msg: + if sock is not None: + sock.close() + + raise error, msg + # Define the SSL support class ssl: -- Repository URL: http://hg.python.org/jython From jython-checkins at python.org Wed Nov 2 10:47:50 2011 From: jython-checkins at python.org (alan.kennedy) Date: Wed, 02 Nov 2011 10:47:50 +0100 Subject: [Jython-checkins] =?utf8?q?jython_=28merge_2=2E5_-=3E_default=29?= =?utf8?q?=3A_merge_with_2=2E5=3A_Introducing_socket=2Ecreate=5Fconnection?= =?utf8?q?=2E?= Message-ID: http://hg.python.org/jython/rev/47134672d506 changeset: 6271:47134672d506 parent: 6269:386860c0254c parent: 6270:cc548bacc001 user: Alan Kennedy date: Wed Nov 02 09:47:06 2011 +0000 summary: merge with 2.5: Introducing socket.create_connection. files: Lib/socket.py | 29 +++++++++++++++++++++++++++++ 1 files changed, 29 insertions(+), 0 deletions(-) diff --git a/Lib/socket.py b/Lib/socket.py --- a/Lib/socket.py +++ b/Lib/socket.py @@ -1554,6 +1554,35 @@ _GLOBAL_DEFAULT_TIMEOUT = object() +def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT): + """Connect to *address* and return the socket object. + + Convenience function. Connect to *address* (a 2-tuple ``(host, + port)``) and return the socket object. Passing the optional + *timeout* parameter will set the timeout on the socket instance + before attempting to connect. If no *timeout* is supplied, the + global default timeout setting returned by :func:`getdefaulttimeout` + is used. + """ + + msg = "getaddrinfo returns an empty list" + host, port = address + for res in getaddrinfo(host, port, 0, SOCK_STREAM): + af, socktype, proto, canonname, sa = res + sock = None + try: + sock = socket(af, socktype, proto) + if timeout is not _GLOBAL_DEFAULT_TIMEOUT: + sock.settimeout(timeout) + sock.connect(sa) + return sock + + except error, msg: + if sock is not None: + sock.close() + + raise error, msg + # Define the SSL support class ssl: -- Repository URL: http://hg.python.org/jython From jython-checkins at python.org Mon Nov 7 02:55:55 2011 From: jython-checkins at python.org (philip.jenvey) Date: Mon, 07 Nov 2011 02:55:55 +0100 Subject: [Jython-checkins] =?utf8?b?anl0aG9uOiBhZGQgX19idWlsdGluX18ubmV4?= =?utf8?q?t?= Message-ID: http://hg.python.org/jython/rev/91b69979ac44 changeset: 6273:91b69979ac44 user: Philip Jenvey date: Sun Nov 06 17:54:18 2011 -0800 summary: add __builtin__.next files: src/org/python/core/__builtin__.java | 32 ++++++++++++++++ 1 files changed, 32 insertions(+), 0 deletions(-) diff --git a/src/org/python/core/__builtin__.java b/src/org/python/core/__builtin__.java --- a/src/org/python/core/__builtin__.java +++ b/src/org/python/core/__builtin__.java @@ -361,6 +361,7 @@ dict.__setitem__("any", new AnyFunction()); dict.__setitem__("format", new FormatFunction()); dict.__setitem__("print", new PrintFunction()); + dict.__setitem__("next", new NextFunction()); } public static PyObject abs(PyObject o) { @@ -1662,3 +1663,34 @@ return PyFile.TYPE.__call__(args, kwds); } } + +class NextFunction extends PyBuiltinFunction { + NextFunction() { + super("next", "next(iterator[, default])\n\n" + + "Return the next item from the iterator. If default is given and the iterator\n" + + "is exhausted, it is returned instead of raising StopIteration."); + } + + @Override + public PyObject __call__(PyObject args[], String kwds[]) { + ArgParser ap = new ArgParser("next", args, kwds, new String[] {"iterator", "default"}, 1); + ap.noKeywords(); + PyObject it = ap.getPyObject(0); + PyObject def = ap.getPyObject(1, null); + + PyObject next; + if ((next = it.__findattr__("next")) == null) { + throw Py.TypeError(String.format("'%.200s' object is not an iterator", + it.getType().fastGetName())); + } + + try { + return next.__call__(); + } catch (PyException pye) { + if (!pye.match(Py.StopIteration) || def == null) { + throw pye; + } + } + return def; + } +} -- Repository URL: http://hg.python.org/jython From jython-checkins at python.org Mon Nov 7 02:55:55 2011 From: jython-checkins at python.org (philip.jenvey) Date: Mon, 07 Nov 2011 02:55:55 +0100 Subject: [Jython-checkins] =?utf8?q?jython=3A_fix_test=5Fbuiltin=2Etest=5F?= =?utf8?q?neg?= Message-ID: http://hg.python.org/jython/rev/975a2336fcb3 changeset: 6274:975a2336fcb3 user: Philip Jenvey date: Sun Nov 06 17:55:06 2011 -0800 summary: fix test_builtin.test_neg files: src/org/python/core/PyInteger.java | 9 +++++++-- 1 files changed, 7 insertions(+), 2 deletions(-) diff --git a/src/org/python/core/PyInteger.java b/src/org/python/core/PyInteger.java --- a/src/org/python/core/PyInteger.java +++ b/src/org/python/core/PyInteger.java @@ -793,8 +793,13 @@ @ExposedMethod(doc = BuiltinDocs.int___neg___doc) final PyObject int___neg__() { - long x = -getValue(); - return Py.newInteger(x); + long x = getValue(); + long result = -x; + // check for overflow + if (x < 0 && result == x) { + return new PyLong(x).__neg__(); + } + return Py.newInteger(result); } @Override -- Repository URL: http://hg.python.org/jython From jython-checkins at python.org Mon Nov 7 02:55:55 2011 From: jython-checkins at python.org (philip.jenvey) Date: Mon, 07 Nov 2011 02:55:55 +0100 Subject: [Jython-checkins] =?utf8?q?jython=3A_upgrade_test=5Fbuiltin=2Epy?= =?utf8?q?=2C_from=3A?= Message-ID: http://hg.python.org/jython/rev/c160531fada7 changeset: 6272:c160531fada7 user: Philip Jenvey date: Sun Nov 06 17:50:15 2011 -0800 summary: upgrade test_builtin.py, from: https://svn.python.org/projects/python/branches/release26-maint/Lib/test/test_builtin.py at 83628 files: Lib/test/test_builtin.py | 867 ++++++++++---------------- 1 files changed, 348 insertions(+), 519 deletions(-) diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py --- a/Lib/test/test_builtin.py +++ b/Lib/test/test_builtin.py @@ -1,18 +1,17 @@ # Python test set -- built-in functions -import test.test_support, unittest -from test.test_support import fcmp, have_unicode, TESTFN, unlink, \ - run_unittest, is_jython +import platform +import unittest +import warnings +from test.test_support import (fcmp, have_unicode, TESTFN, unlink, + run_unittest, _check_py3k_warnings, check_warnings, + is_jython) from operator import neg -import sys, warnings, cStringIO, random, UserDict -warnings.filterwarnings("ignore", "hex../oct.. of negative int", - FutureWarning, __name__) -warnings.filterwarnings("ignore", "integer argument expected", - DeprecationWarning, "unittest") - +import sys, cStringIO, random, UserDict # count the number of test runs. # used to skip running test_execfile() multiple times +# and to create unique strings to intern in test_intern() numruns = 0 class Squares: @@ -53,45 +52,6 @@ def write(self, line): pass -L = [ - ('0', 0), - ('1', 1), - ('9', 9), - ('10', 10), - ('99', 99), - ('100', 100), - ('314', 314), - (' 314', 314), - ('314 ', 314), - (' \t\t 314 \t\t ', 314), - (repr(sys.maxint), sys.maxint), - (' 1x', ValueError), - (' 1 ', 1), - (' 1\02 ', ValueError), - ('', ValueError), - (' ', ValueError), - (' \t\t ', ValueError) -] -if have_unicode: - L += [ - (unicode('0'), 0), - (unicode('1'), 1), - (unicode('9'), 9), - (unicode('10'), 10), - (unicode('99'), 99), - (unicode('100'), 100), - (unicode('314'), 314), - (unicode(' 314'), 314), - (unicode('\u0663\u0661\u0664 ','raw-unicode-escape'), 314), - (unicode(' \t\t 314 \t\t '), 314), - (unicode(' 1x'), ValueError), - (unicode(' 1 '), 1), - (unicode(' 1\02 '), ValueError), - (unicode(''), ValueError), - (unicode(' '), ValueError), - (unicode(' \t\t '), ValueError), - (unichr(0x200), ValueError), -] class TestFailingBool: def __nonzero__(self): @@ -107,15 +67,19 @@ __import__('sys') __import__('time') __import__('string') + __import__(name='sys') + __import__(name='time', level=0) self.assertRaises(ImportError, __import__, 'spamspam') self.assertRaises(TypeError, __import__, 1, 2, 3, 4) self.assertRaises(ValueError, __import__, '') + self.assertRaises(TypeError, __import__, 'sys', name='sys') def test_abs(self): # int self.assertEqual(abs(0), 0) self.assertEqual(abs(1234), 1234) self.assertEqual(abs(-1234), 1234) + self.assertTrue(abs(-sys.maxint-1) > 0) # float self.assertEqual(abs(0.0), 0.0) self.assertEqual(abs(3.14), 3.14) @@ -155,6 +119,11 @@ S = [10, 20, 30] self.assertEqual(any(x > 42 for x in S), False) + def test_neg(self): + x = -sys.maxint-1 + self.assert_(isinstance(x, int)) + self.assertEqual(-x, sys.maxint+1) + def test_apply(self): def f0(*args): self.assertEqual(args, ()) @@ -237,15 +206,21 @@ compile('print 1\n', '', 'exec') bom = '\xef\xbb\xbf' compile(bom + 'print 1\n', '', 'exec') + compile(source='pass', filename='?', mode='exec') + compile(dont_inherit=0, filename='tmp', source='0', mode='eval') + compile('pass', '?', dont_inherit=1, mode='exec') self.assertRaises(TypeError, compile) self.assertRaises(ValueError, compile, 'print 42\n', '', 'badmode') self.assertRaises(ValueError, compile, 'print 42\n', '', 'single', 0xff) self.assertRaises(TypeError, compile, chr(0), 'f', 'exec') + self.assertRaises(TypeError, compile, 'pass', '?', 'exec', + mode='eval', source='0', filename='tmp') if have_unicode: compile(unicode('print u"\xc3\xa5"\n', 'utf8'), '', 'exec') self.assertRaises(TypeError, compile, unichr(0), 'f', 'exec') self.assertRaises(ValueError, compile, unicode('a = 1'), 'f', 'bad') + def test_delattr(self): import sys sys.spam = 1 @@ -253,11 +228,66 @@ self.assertRaises(TypeError, delattr) def test_dir(self): - x = 1 - self.assert_('x' in dir()) + # dir(wrong number of arguments) + self.assertRaises(TypeError, dir, 42, 42) + + # dir() - local scope + local_var = 1 + self.assert_('local_var' in dir()) + + # dir(module) import sys - self.assert_('modules' in dir(sys)) - self.assertRaises(TypeError, dir, 42, 42) + self.assert_('exit' in dir(sys)) + + # dir(module_with_invalid__dict__) + import types + class Foo(types.ModuleType): + __dict__ = 8 + f = Foo("foo") + self.assertRaises(TypeError, dir, f) + + # dir(type) + self.assert_("strip" in dir(str)) + self.assert_("__mro__" not in dir(str)) + + # dir(obj) + class Foo(object): + def __init__(self): + self.x = 7 + self.y = 8 + self.z = 9 + f = Foo() + self.assert_("y" in dir(f)) + + # dir(obj_no__dict__) + class Foo(object): + __slots__ = [] + f = Foo() + self.assert_("__repr__" in dir(f)) + + # dir(obj_no__class__with__dict__) + # (an ugly trick to cause getattr(f, "__class__") to fail) + class Foo(object): + __slots__ = ["__class__", "__dict__"] + def __init__(self): + self.bar = "wow" + f = Foo() + self.assert_("__repr__" not in dir(f)) + self.assert_("bar" in dir(f)) + + # dir(obj_using __dir__) + class Foo(object): + def __dir__(self): + return ["kan", "ga", "roo"] + f = Foo() + self.assert_(dir(f) == ["ga", "kan", "roo"]) + + # dir(obj__dir__not_list) + class Foo(object): + def __dir__(self): + return 7 + f = Foo() + self.assertRaises(TypeError, dir, f) def test_divmod(self): self.assertEqual(divmod(12, 7), (1, 5)) @@ -388,7 +418,9 @@ f.write('z = z+1\n') f.write('z = z*2\n') f.close() - execfile(TESTFN) + with _check_py3k_warnings(("execfile.. not supported in 3.x", + DeprecationWarning)): + execfile(TESTFN) def test_execfile(self): global numruns @@ -544,88 +576,6 @@ self.assertEqual(outp, exp) self.assert_(not isinstance(outp, cls)) - def test_float(self): - self.assertEqual(float(3.14), 3.14) - self.assertEqual(float(314), 314.0) - self.assertEqual(float(314L), 314.0) - self.assertEqual(float(" 3.14 "), 3.14) - self.assertRaises(ValueError, float, " 0x3.1 ") - #XXX: Java can handle conversions of BinaryExponentIndicator (the p - # below) as well as floating hex. Thanks to Tobias Ivarsson for - # noticing this in the Java Language Spec. For us this is - # cross-platform - and the comments for this checkin by Neal - # Norwitz say this check is part of making things more platform - # neutral. I'm leaving this test out until we find out whether or - # not this is an implementation detail of CPython - if not is_jython: - self.assertRaises(ValueError, float, " -0x3.p-1 ") - if have_unicode: - self.assertEqual(float(unicode(" 3.14 ")), 3.14) - self.assertEqual(float(unicode(" \u0663.\u0661\u0664 ",'raw-unicode-escape')), 3.14) - # Implementation limitation in PyFloat_FromString() - # XXX: but not in Jython. - if is_jython: - self.assertEquals(float(unicode("1"*10000)), float(unicode("1"*10000))) - else: - self.assertRaises(ValueError, float, unicode("1"*10000)) - -# @run_with_locale('LC_NUMERIC', 'fr_FR', 'de_DE') -# def test_float_with_comma(self): -# # set locale to something that doesn't use '.' for the decimal point -# # float must not accept the locale specific decimal point but -# # it still has to accept the normal python syntac -# import locale -# if not locale.localeconv()['decimal_point'] == ',': -# return - -# self.assertEqual(float(" 3.14 "), 3.14) -# self.assertEqual(float("+3.14 "), 3.14) -# self.assertEqual(float("-3.14 "), -3.14) -# self.assertEqual(float(".14 "), .14) -# self.assertEqual(float("3. "), 3.0) -# self.assertEqual(float("3.e3 "), 3000.0) -# self.assertEqual(float("3.2e3 "), 3200.0) -# self.assertEqual(float("2.5e-1 "), 0.25) -# self.assertEqual(float("5e-1"), 0.5) -# self.assertRaises(ValueError, float, " 3,14 ") -# self.assertRaises(ValueError, float, " +3,14 ") -# self.assertRaises(ValueError, float, " -3,14 ") -# self.assertRaises(ValueError, float, " 0x3.1 ") -# self.assertRaises(ValueError, float, " -0x3.p-1 ") -# self.assertEqual(float(" 25.e-1 "), 2.5) -# self.assertEqual(fcmp(float(" .25e-1 "), .025), 0) - - def test_floatconversion(self): - # Make sure that calls to __float__() work properly - class Foo0: - def __float__(self): - return 42. - - class Foo1(object): - def __float__(self): - return 42. - - class Foo2(float): - def __float__(self): - return 42. - - class Foo3(float): - def __new__(cls, value=0.): - return float.__new__(cls, 2*value) - - def __float__(self): - return self - - class Foo4(float): - def __float__(self): - return 42 - - self.assertAlmostEqual(float(Foo0()), 42.) - self.assertAlmostEqual(float(Foo1()), 42.) - self.assertAlmostEqual(float(Foo2()), 42.) - self.assertAlmostEqual(float(Foo3(21)), 42.) - self.assertRaises(TypeError, float, Foo4(42)) - def test_getattr(self): import sys self.assert_(getattr(sys, 'stdout') is sys.stdout) @@ -643,6 +593,16 @@ if have_unicode: self.assertRaises(UnicodeError, hasattr, sys, unichr(sys.maxunicode)) + # Check that hasattr allows SystemExit and KeyboardInterrupts by + class A: + def __getattr__(self, what): + raise KeyboardInterrupt + self.assertRaises(KeyboardInterrupt, hasattr, A(), "b") + class B: + def __getattr__(self, what): + raise SystemExit + self.assertRaises(SystemExit, hasattr, B(), "b") + def test_hash(self): hash(None) self.assertEqual(hash(1), hash(1L)) @@ -687,180 +647,11 @@ # Test input() later, together with raw_input - def test_int(self): - self.assertEqual(int(314), 314) - self.assertEqual(int(3.14), 3) - self.assertEqual(int(314L), 314) - # Check that conversion from float truncates towards zero - self.assertEqual(int(-3.14), -3) - self.assertEqual(int(3.9), 3) - self.assertEqual(int(-3.9), -3) - self.assertEqual(int(3.5), 3) - self.assertEqual(int(-3.5), -3) - # Different base: - self.assertEqual(int("10",16), 16L) - if have_unicode: - self.assertEqual(int(unicode("10"),16), 16L) - # Test conversion from strings and various anomalies - for s, v in L: - for sign in "", "+", "-": - for prefix in "", " ", "\t", " \t\t ": - ss = prefix + sign + s - vv = v - if sign == "-" and v is not ValueError: - vv = -v - try: - self.assertEqual(int(ss), vv) - except v: - pass - - s = repr(-1-sys.maxint) - self.assertEqual(int(s)+1, -sys.maxint) - # should return long - int(s[1:]) - - # should return long - x = int(1e100) - self.assert_(isinstance(x, long)) - x = int(-1e100) - self.assert_(isinstance(x, long)) - - - # SF bug 434186: 0x80000000/2 != 0x80000000>>1. - # Worked by accident in Windows release build, but failed in debug build. - # Failed in all Linux builds. - x = -1-sys.maxint - self.assertEqual(x >> 1, x//2) - - self.assertRaises(ValueError, int, '123\0') - self.assertRaises(ValueError, int, '53', 40) - - x = int('1' * 600) - self.assert_(isinstance(x, long)) - - if have_unicode: - x = int(unichr(0x661) * 600) - self.assert_(isinstance(x, long)) - - self.assertRaises(TypeError, int, 1, 12) - - self.assertEqual(int('0123', 0), 83) - self.assertEqual(int('0x123', 16), 291) - - # SF bug 1334662: int(string, base) wrong answers - # Various representations of 2**32 evaluated to 0 - # rather than 2**32 in previous versions - - self.assertEqual(int('100000000000000000000000000000000', 2), 4294967296L) - self.assertEqual(int('102002022201221111211', 3), 4294967296L) - self.assertEqual(int('10000000000000000', 4), 4294967296L) - self.assertEqual(int('32244002423141', 5), 4294967296L) - self.assertEqual(int('1550104015504', 6), 4294967296L) - self.assertEqual(int('211301422354', 7), 4294967296L) - self.assertEqual(int('40000000000', 8), 4294967296L) - self.assertEqual(int('12068657454', 9), 4294967296L) - self.assertEqual(int('4294967296', 10), 4294967296L) - self.assertEqual(int('1904440554', 11), 4294967296L) - self.assertEqual(int('9ba461594', 12), 4294967296L) - self.assertEqual(int('535a79889', 13), 4294967296L) - self.assertEqual(int('2ca5b7464', 14), 4294967296L) - self.assertEqual(int('1a20dcd81', 15), 4294967296L) - self.assertEqual(int('100000000', 16), 4294967296L) - self.assertEqual(int('a7ffda91', 17), 4294967296L) - self.assertEqual(int('704he7g4', 18), 4294967296L) - self.assertEqual(int('4f5aff66', 19), 4294967296L) - self.assertEqual(int('3723ai4g', 20), 4294967296L) - self.assertEqual(int('281d55i4', 21), 4294967296L) - self.assertEqual(int('1fj8b184', 22), 4294967296L) - self.assertEqual(int('1606k7ic', 23), 4294967296L) - self.assertEqual(int('mb994ag', 24), 4294967296L) - self.assertEqual(int('hek2mgl', 25), 4294967296L) - self.assertEqual(int('dnchbnm', 26), 4294967296L) - self.assertEqual(int('b28jpdm', 27), 4294967296L) - self.assertEqual(int('8pfgih4', 28), 4294967296L) - self.assertEqual(int('76beigg', 29), 4294967296L) - self.assertEqual(int('5qmcpqg', 30), 4294967296L) - self.assertEqual(int('4q0jto4', 31), 4294967296L) - self.assertEqual(int('4000000', 32), 4294967296L) - self.assertEqual(int('3aokq94', 33), 4294967296L) - self.assertEqual(int('2qhxjli', 34), 4294967296L) - self.assertEqual(int('2br45qb', 35), 4294967296L) - self.assertEqual(int('1z141z4', 36), 4294967296L) - - # SF bug 1334662: int(string, base) wrong answers - # Checks for proper evaluation of 2**32 + 1 - self.assertEqual(int('100000000000000000000000000000001', 2), 4294967297L) - self.assertEqual(int('102002022201221111212', 3), 4294967297L) - self.assertEqual(int('10000000000000001', 4), 4294967297L) - self.assertEqual(int('32244002423142', 5), 4294967297L) - self.assertEqual(int('1550104015505', 6), 4294967297L) - self.assertEqual(int('211301422355', 7), 4294967297L) - self.assertEqual(int('40000000001', 8), 4294967297L) - self.assertEqual(int('12068657455', 9), 4294967297L) - self.assertEqual(int('4294967297', 10), 4294967297L) - self.assertEqual(int('1904440555', 11), 4294967297L) - self.assertEqual(int('9ba461595', 12), 4294967297L) - self.assertEqual(int('535a7988a', 13), 4294967297L) - self.assertEqual(int('2ca5b7465', 14), 4294967297L) - self.assertEqual(int('1a20dcd82', 15), 4294967297L) - self.assertEqual(int('100000001', 16), 4294967297L) - self.assertEqual(int('a7ffda92', 17), 4294967297L) - self.assertEqual(int('704he7g5', 18), 4294967297L) - self.assertEqual(int('4f5aff67', 19), 4294967297L) - self.assertEqual(int('3723ai4h', 20), 4294967297L) - self.assertEqual(int('281d55i5', 21), 4294967297L) - self.assertEqual(int('1fj8b185', 22), 4294967297L) - self.assertEqual(int('1606k7id', 23), 4294967297L) - self.assertEqual(int('mb994ah', 24), 4294967297L) - self.assertEqual(int('hek2mgm', 25), 4294967297L) - self.assertEqual(int('dnchbnn', 26), 4294967297L) - self.assertEqual(int('b28jpdn', 27), 4294967297L) - self.assertEqual(int('8pfgih5', 28), 4294967297L) - self.assertEqual(int('76beigh', 29), 4294967297L) - self.assertEqual(int('5qmcpqh', 30), 4294967297L) - self.assertEqual(int('4q0jto5', 31), 4294967297L) - self.assertEqual(int('4000001', 32), 4294967297L) - self.assertEqual(int('3aokq95', 33), 4294967297L) - self.assertEqual(int('2qhxjlj', 34), 4294967297L) - self.assertEqual(int('2br45qc', 35), 4294967297L) - self.assertEqual(int('1z141z5', 36), 4294967297L) - - def test_intconversion(self): - # Test __int__() - class Foo0: - def __int__(self): - return 42 - - class Foo1(object): - def __int__(self): - return 42 - - class Foo2(int): - def __int__(self): - return 42 - - class Foo3(int): - def __int__(self): - return self - - class Foo4(int): - def __int__(self): - return 42L - - class Foo5(int): - def __int__(self): - return 42. - - self.assertEqual(int(Foo0()), 42) - self.assertEqual(int(Foo1()), 42) - self.assertEqual(int(Foo2()), 42) - self.assertEqual(int(Foo3()), 0) - self.assertEqual(int(Foo4()), 42L) - self.assertRaises(TypeError, int, Foo5()) - def test_intern(self): self.assertRaises(TypeError, intern) - s = "never interned before" + # This fails if the test is run twice with a constant string, + # therefore append the run counter + s = "never interned before " + str(numruns) self.assert_(intern(s) is s) s2 = s.swapcase().swapcase() self.assert_(intern(s2) is s) @@ -941,191 +732,6 @@ raise ValueError self.assertRaises(ValueError, len, BadSeq()) - def test_list(self): - self.assertEqual(list([]), []) - l0_3 = [0, 1, 2, 3] - l0_3_bis = list(l0_3) - self.assertEqual(l0_3, l0_3_bis) - self.assert_(l0_3 is not l0_3_bis) - self.assertEqual(list(()), []) - self.assertEqual(list((0, 1, 2, 3)), [0, 1, 2, 3]) - self.assertEqual(list(''), []) - self.assertEqual(list('spam'), ['s', 'p', 'a', 'm']) - - if sys.maxint == 0x7fffffff and not test.test_support.is_jython: - # This test can currently only work on 32-bit machines. - # XXX If/when PySequence_Length() returns a ssize_t, it should be - # XXX re-enabled. - # Verify clearing of bug #556025. - # This assumes that the max data size (sys.maxint) == max - # address size this also assumes that the address size is at - # least 4 bytes with 8 byte addresses, the bug is not well - # tested - # - # Note: This test is expected to SEGV under Cygwin 1.3.12 or - # earlier due to a newlib bug. See the following mailing list - # thread for the details: - - # http://sources.redhat.com/ml/newlib/2002/msg00369.html - self.assertRaises(MemoryError, list, xrange(sys.maxint // 2)) - - # This code used to segfault in Py2.4a3 - x = [] - x.extend(-y for y in x) - self.assertEqual(x, []) - - def test_long(self): - self.assertEqual(long(314), 314L) - self.assertEqual(long(3.14), 3L) - self.assertEqual(long(314L), 314L) - # Check that conversion from float truncates towards zero - self.assertEqual(long(-3.14), -3L) - self.assertEqual(long(3.9), 3L) - self.assertEqual(long(-3.9), -3L) - self.assertEqual(long(3.5), 3L) - self.assertEqual(long(-3.5), -3L) - self.assertEqual(long("-3"), -3L) - if have_unicode: - self.assertEqual(long(unicode("-3")), -3L) - # Different base: - self.assertEqual(long("10",16), 16L) - if have_unicode: - self.assertEqual(long(unicode("10"),16), 16L) - # Check conversions from string (same test set as for int(), and then some) - LL = [ - ('1' + '0'*20, 10L**20), - ('1' + '0'*100, 10L**100) - ] - L2 = L[:] - if have_unicode: - L2 += [ - (unicode('1') + unicode('0')*20, 10L**20), - (unicode('1') + unicode('0')*100, 10L**100), - ] - for s, v in L2 + LL: - for sign in "", "+", "-": - for prefix in "", " ", "\t", " \t\t ": - ss = prefix + sign + s - vv = v - if sign == "-" and v is not ValueError: - vv = -v - try: - self.assertEqual(long(ss), long(vv)) - except v: - pass - - self.assertRaises(ValueError, long, '123\0') - self.assertRaises(ValueError, long, '53', 40) - self.assertRaises(TypeError, long, 1, 12) - - self.assertEqual(long('100000000000000000000000000000000', 2), - 4294967296) - self.assertEqual(long('102002022201221111211', 3), 4294967296) - self.assertEqual(long('10000000000000000', 4), 4294967296) - self.assertEqual(long('32244002423141', 5), 4294967296) - self.assertEqual(long('1550104015504', 6), 4294967296) - self.assertEqual(long('211301422354', 7), 4294967296) - self.assertEqual(long('40000000000', 8), 4294967296) - self.assertEqual(long('12068657454', 9), 4294967296) - self.assertEqual(long('4294967296', 10), 4294967296) - self.assertEqual(long('1904440554', 11), 4294967296) - self.assertEqual(long('9ba461594', 12), 4294967296) - self.assertEqual(long('535a79889', 13), 4294967296) - self.assertEqual(long('2ca5b7464', 14), 4294967296) - self.assertEqual(long('1a20dcd81', 15), 4294967296) - self.assertEqual(long('100000000', 16), 4294967296) - self.assertEqual(long('a7ffda91', 17), 4294967296) - self.assertEqual(long('704he7g4', 18), 4294967296) - self.assertEqual(long('4f5aff66', 19), 4294967296) - self.assertEqual(long('3723ai4g', 20), 4294967296) - self.assertEqual(long('281d55i4', 21), 4294967296) - self.assertEqual(long('1fj8b184', 22), 4294967296) - self.assertEqual(long('1606k7ic', 23), 4294967296) - self.assertEqual(long('mb994ag', 24), 4294967296) - self.assertEqual(long('hek2mgl', 25), 4294967296) - self.assertEqual(long('dnchbnm', 26), 4294967296) - self.assertEqual(long('b28jpdm', 27), 4294967296) - self.assertEqual(long('8pfgih4', 28), 4294967296) - self.assertEqual(long('76beigg', 29), 4294967296) - self.assertEqual(long('5qmcpqg', 30), 4294967296) - self.assertEqual(long('4q0jto4', 31), 4294967296) - self.assertEqual(long('4000000', 32), 4294967296) - self.assertEqual(long('3aokq94', 33), 4294967296) - self.assertEqual(long('2qhxjli', 34), 4294967296) - self.assertEqual(long('2br45qb', 35), 4294967296) - self.assertEqual(long('1z141z4', 36), 4294967296) - - self.assertEqual(long('100000000000000000000000000000001', 2), - 4294967297) - self.assertEqual(long('102002022201221111212', 3), 4294967297) - self.assertEqual(long('10000000000000001', 4), 4294967297) - self.assertEqual(long('32244002423142', 5), 4294967297) - self.assertEqual(long('1550104015505', 6), 4294967297) - self.assertEqual(long('211301422355', 7), 4294967297) - self.assertEqual(long('40000000001', 8), 4294967297) - self.assertEqual(long('12068657455', 9), 4294967297) - self.assertEqual(long('4294967297', 10), 4294967297) - self.assertEqual(long('1904440555', 11), 4294967297) - self.assertEqual(long('9ba461595', 12), 4294967297) - self.assertEqual(long('535a7988a', 13), 4294967297) - self.assertEqual(long('2ca5b7465', 14), 4294967297) - self.assertEqual(long('1a20dcd82', 15), 4294967297) - self.assertEqual(long('100000001', 16), 4294967297) - self.assertEqual(long('a7ffda92', 17), 4294967297) - self.assertEqual(long('704he7g5', 18), 4294967297) - self.assertEqual(long('4f5aff67', 19), 4294967297) - self.assertEqual(long('3723ai4h', 20), 4294967297) - self.assertEqual(long('281d55i5', 21), 4294967297) - self.assertEqual(long('1fj8b185', 22), 4294967297) - self.assertEqual(long('1606k7id', 23), 4294967297) - self.assertEqual(long('mb994ah', 24), 4294967297) - self.assertEqual(long('hek2mgm', 25), 4294967297) - self.assertEqual(long('dnchbnn', 26), 4294967297) - self.assertEqual(long('b28jpdn', 27), 4294967297) - self.assertEqual(long('8pfgih5', 28), 4294967297) - self.assertEqual(long('76beigh', 29), 4294967297) - self.assertEqual(long('5qmcpqh', 30), 4294967297) - self.assertEqual(long('4q0jto5', 31), 4294967297) - self.assertEqual(long('4000001', 32), 4294967297) - self.assertEqual(long('3aokq95', 33), 4294967297) - self.assertEqual(long('2qhxjlj', 34), 4294967297) - self.assertEqual(long('2br45qc', 35), 4294967297) - self.assertEqual(long('1z141z5', 36), 4294967297) - - - def test_longconversion(self): - # Test __long__() - class Foo0: - def __long__(self): - return 42L - - class Foo1(object): - def __long__(self): - return 42L - - class Foo2(long): - def __long__(self): - return 42L - - class Foo3(long): - def __long__(self): - return self - - class Foo4(long): - def __long__(self): - return 42 - - class Foo5(long): - def __long__(self): - return 42. - - self.assertEqual(long(Foo0()), 42L) - self.assertEqual(long(Foo1()), 42L) - self.assertEqual(long(Foo2()), 42L) - self.assertEqual(long(Foo3()), 0) - self.assertEqual(long(Foo4()), 42) - self.assertRaises(TypeError, long, Foo5()) - def test_map(self): self.assertEqual( map(None, 'hello world'), @@ -1280,6 +886,33 @@ self.assertEqual(min(data, key=f), sorted(data, key=f)[0]) + def test_next(self): + it = iter(range(2)) + self.assertEqual(next(it), 0) + self.assertEqual(next(it), 1) + self.assertRaises(StopIteration, next, it) + self.assertRaises(StopIteration, next, it) + self.assertEquals(next(it, 42), 42) + + class Iter(object): + def __iter__(self): + return self + def next(self): + raise StopIteration + + it = iter(Iter()) + self.assertEquals(next(it, 42), 42) + self.assertRaises(StopIteration, next, it) + + def gen(): + yield 1 + return + + it = gen() + self.assertEquals(next(it), 1) + self.assertRaises(StopIteration, next, it) + self.assertEquals(next(it, 42), 42) + def test_oct(self): self.assertEqual(oct(100), '0144') self.assertEqual(oct(100L), '0144L') @@ -1386,6 +1019,7 @@ self.assertRaises(ValueError, pow, 1, 2, 0) self.assertRaises(TypeError, pow, -1L, -2L, 3L) self.assertRaises(ValueError, pow, 1L, 2L, 0L) + # Will return complex in 3.0: self.assertRaises(ValueError, pow, -342.43, 0.234) self.assertRaises(TypeError, pow) @@ -1435,11 +1069,17 @@ class badzero(int): def __cmp__(self, other): raise RuntimeError + __hash__ = None # Invalid cmp makes this unhashable self.assertRaises(RuntimeError, range, a, a + 1, badzero(1)) # Reject floats when it would require PyLongs to represent. # (smaller floats still accepted, but deprecated) - self.assertRaises(TypeError, range, 1e100, 1e101, 1e101) + with check_warnings() as w: + warnings.simplefilter("always") + self.assertRaises(TypeError, range, 1e100, 1e101, 1e101) + with check_warnings() as w: + warnings.simplefilter("always") + self.assertEqual(range(1.0), [0]) self.assertRaises(TypeError, range, 0, "spam") self.assertRaises(TypeError, range, 0, 42, "spam") @@ -1447,6 +1087,55 @@ self.assertRaises(OverflowError, range, -sys.maxint, sys.maxint) self.assertRaises(OverflowError, range, 0, 2*sys.maxint) + bignum = 2*sys.maxint + smallnum = 42 + # Old-style user-defined class with __int__ method + class I0: + def __init__(self, n): + self.n = int(n) + def __int__(self): + return self.n + self.assertEqual(range(I0(bignum), I0(bignum + 1)), [bignum]) + self.assertEqual(range(I0(smallnum), I0(smallnum + 1)), [smallnum]) + + # New-style user-defined class with __int__ method + class I1(object): + def __init__(self, n): + self.n = int(n) + def __int__(self): + return self.n + self.assertEqual(range(I1(bignum), I1(bignum + 1)), [bignum]) + self.assertEqual(range(I1(smallnum), I1(smallnum + 1)), [smallnum]) + + # New-style user-defined class with failing __int__ method + class IX(object): + def __int__(self): + raise RuntimeError + self.assertRaises(RuntimeError, range, IX()) + + # New-style user-defined class with invalid __int__ method + class IN(object): + def __int__(self): + return "not a number" + self.assertRaises(TypeError, range, IN()) + + # Exercise various combinations of bad arguments, to check + # refcounting logic + with check_warnings(): + self.assertRaises(TypeError, range, 1e100) + + self.assertRaises(TypeError, range, 0, 1e100) + self.assertRaises(TypeError, range, 1e100, 0) + self.assertRaises(TypeError, range, 1e100, 1e100) + + self.assertRaises(TypeError, range, 0, 0, 1e100) + self.assertRaises(TypeError, range, 0, 1e100, 1) + self.assertRaises(TypeError, range, 0, 1e100, 1e100) + self.assertRaises(TypeError, range, 1e100, 0, 1) + self.assertRaises(TypeError, range, 1e100, 0, 1e100) + self.assertRaises(TypeError, range, 1e100, 1e100, 1) + self.assertRaises(TypeError, range, 1e100, 1e100, 1e100) + def test_input_and_raw_input(self): self.write_testfile() fp = open(TESTFN, 'r') @@ -1554,6 +1243,7 @@ def test_round(self): self.assertEqual(round(0.0), 0.0) + self.assertEqual(type(round(0.0)), float) # Will be int in 3.0. self.assertEqual(round(1.0), 1.0) self.assertEqual(round(10.0), 10.0) self.assertEqual(round(1000000000.0), 1000000000.0) @@ -1582,32 +1272,63 @@ self.assertEqual(round(-999999999.9), -1000000000.0) self.assertEqual(round(-8.0, -1), -10.0) + self.assertEqual(type(round(-8.0, -1)), float) + + self.assertEqual(type(round(-8.0, 0)), float) + self.assertEqual(type(round(-8.0, 1)), float) + + # Check half rounding behaviour. + self.assertEqual(round(5.5), 6) + self.assertEqual(round(6.5), 7) + self.assertEqual(round(-5.5), -6) + self.assertEqual(round(-6.5), -7) + + # Check behavior on ints + self.assertEqual(round(0), 0) + self.assertEqual(round(8), 8) + self.assertEqual(round(-8), -8) + self.assertEqual(type(round(0)), float) # Will be int in 3.0. + self.assertEqual(type(round(-8, -1)), float) + self.assertEqual(type(round(-8, 0)), float) + self.assertEqual(type(round(-8, 1)), float) # test new kwargs self.assertEqual(round(number=-8.0, ndigits=-1), -10.0) self.assertRaises(TypeError, round) + # test generic rounding delegation for reals + class TestRound(object): + def __float__(self): + return 23.0 + + class TestNoRound(object): + pass + + self.assertEqual(round(TestRound()), 23) + + self.assertRaises(TypeError, round, 1, 2, 3) + self.assertRaises(TypeError, round, TestNoRound()) + + t = TestNoRound() + t.__float__ = lambda *args: args + self.assertRaises(TypeError, round, t) + self.assertRaises(TypeError, round, t, 0) + + def test_round_large(self): + # Issue #1869: integral floats should remain unchanged + self.assertEqual(round(5e15-1), 5e15-1) + self.assertEqual(round(5e15), 5e15) + self.assertEqual(round(5e15+1), 5e15+1) + self.assertEqual(round(5e15+2), 5e15+2) + self.assertEqual(round(5e15+3), 5e15+3) + def test_setattr(self): setattr(sys, 'spam', 1) self.assertEqual(sys.spam, 1) self.assertRaises(TypeError, setattr, sys, 1, 'spam') self.assertRaises(TypeError, setattr) - def test_str(self): - self.assertEqual(str(''), '') - self.assertEqual(str(0), '0') - self.assertEqual(str(0L), '0') - self.assertEqual(str(()), '()') - self.assertEqual(str([]), '[]') - self.assertEqual(str({}), '{}') - a = [] - a.append(a) - self.assertEqual(str(a), '[[...]]') - a = {} - a[0] = a - self.assertEqual(str(a), '{0: {...}}') - def test_sum(self): self.assertEqual(sum([]), 0) self.assertEqual(sum(range(2,8)), 27) @@ -1629,16 +1350,6 @@ raise ValueError self.assertRaises(ValueError, sum, BadSeq()) - def test_tuple(self): - self.assertEqual(tuple(()), ()) - t0_3 = (0, 1, 2, 3) - t0_3_bis = tuple(t0_3) - self.assert_(t0_3 is t0_3_bis) - self.assertEqual(tuple([]), ()) - self.assertEqual(tuple([0, 1, 2, 3]), (0, 1, 2, 3)) - self.assertEqual(tuple(''), ()) - self.assertEqual(tuple('spam'), ('s', 'p', 'a', 'm')) - def test_type(self): self.assertEqual(type(''), type('123')) self.assertNotEqual(type(''), type(())) @@ -1654,6 +1365,7 @@ ) self.assertRaises(ValueError, unichr, sys.maxunicode+1) self.assertRaises(TypeError, unichr) + self.assertRaises((OverflowError, ValueError), unichr, 2**32) # We don't want self in vars(), so these are static methods @@ -1720,6 +1432,115 @@ return i self.assertRaises(ValueError, zip, BadSeq(), BadSeq()) + def test_format(self): + # Test the basic machinery of the format() builtin. Don't test + # the specifics of the various formatters + self.assertEqual(format(3, ''), '3') + + # Returns some classes to use for various tests. There's + # an old-style version, and a new-style version + def classes_new(): + class A(object): + def __init__(self, x): + self.x = x + def __format__(self, format_spec): + return str(self.x) + format_spec + class DerivedFromA(A): + pass + + class Simple(object): pass + class DerivedFromSimple(Simple): + def __init__(self, x): + self.x = x + def __format__(self, format_spec): + return str(self.x) + format_spec + class DerivedFromSimple2(DerivedFromSimple): pass + return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2 + + # In 3.0, classes_classic has the same meaning as classes_new + def classes_classic(): + class A: + def __init__(self, x): + self.x = x + def __format__(self, format_spec): + return str(self.x) + format_spec + class DerivedFromA(A): + pass + + class Simple: pass + class DerivedFromSimple(Simple): + def __init__(self, x): + self.x = x + def __format__(self, format_spec): + return str(self.x) + format_spec + class DerivedFromSimple2(DerivedFromSimple): pass + return A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2 + + def class_test(A, DerivedFromA, DerivedFromSimple, DerivedFromSimple2): + self.assertEqual(format(A(3), 'spec'), '3spec') + self.assertEqual(format(DerivedFromA(4), 'spec'), '4spec') + self.assertEqual(format(DerivedFromSimple(5), 'abc'), '5abc') + self.assertEqual(format(DerivedFromSimple2(10), 'abcdef'), + '10abcdef') + + class_test(*classes_new()) + class_test(*classes_classic()) + + def empty_format_spec(value): + # test that: + # format(x, '') == str(x) + # format(x) == str(x) + self.assertEqual(format(value, ""), str(value)) + self.assertEqual(format(value), str(value)) + + # for builtin types, format(x, "") == str(x) + empty_format_spec(17**13) + empty_format_spec(1.0) + empty_format_spec(3.1415e104) + empty_format_spec(-3.1415e104) + empty_format_spec(3.1415e-104) + empty_format_spec(-3.1415e-104) + empty_format_spec(object) + empty_format_spec(None) + + # TypeError because self.__format__ returns the wrong type + class BadFormatResult: + def __format__(self, format_spec): + return 1.0 + self.assertRaises(TypeError, format, BadFormatResult(), "") + + # TypeError because format_spec is not unicode or str + self.assertRaises(TypeError, format, object(), 4) + self.assertRaises(TypeError, format, object(), object()) + + # tests for object.__format__ really belong elsewhere, but + # there's no good place to put them + x = object().__format__('') + self.assert_(x.startswith('