Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Lib/test/test_cookielib.py

    r2 r391  
    22"""Tests for cookielib.py."""
    33
    4 import re, os, time
     4import cookielib
     5import os
     6import re
     7import time
     8
    59from unittest import TestCase
    610
    711from test import test_support
     12
    813
    914class DateTimeTests(TestCase):
    … …  
    1419        base = 1019227000
    1520        day = 24*3600
    16         self.assertEquals(time2isoz(base), "2002-04-19 14:36:40Z")
    17         self.assertEquals(time2isoz(base+day), "2002-04-20 14:36:40Z")
    18         self.assertEquals(time2isoz(base+2*day), "2002-04-21 14:36:40Z")
    19         self.assertEquals(time2isoz(base+3*day), "2002-04-22 14:36:40Z")
     21        self.assertEqual(time2isoz(base), "2002-04-19 14:36:40Z")
     22        self.assertEqual(time2isoz(base+day), "2002-04-20 14:36:40Z")
     23        self.assertEqual(time2isoz(base+2*day), "2002-04-21 14:36:40Z")
     24        self.assertEqual(time2isoz(base+3*day), "2002-04-22 14:36:40Z")
    2025
    2126        az = time2isoz()
    2227        bz = time2isoz(500000)
    2328        for text in (az, bz):
    24             self.assert_(re.search(r"^\d{4}-\d\d-\d\d \d\d:\d\d:\d\dZ$", text),
     29            self.assertTrue(re.search(r"^\d{4}-\d\d-\d\d \d\d:\d\d:\d\dZ$", text),
    2530                         "bad time2isoz format: %s %s" % (az, bz))
    2631
    … …  
    3136            return time.gmtime(http2time(text))[:6]
    3237
    33         self.assertEquals(parse_date("01 Jan 2001"), (2001, 1, 1, 0, 0, 0.0))
     38        self.assertEqual(parse_date("01 Jan 2001"), (2001, 1, 1, 0, 0, 0.0))
    3439
    3540        # this test will break around year 2070
    36         self.assertEquals(parse_date("03-Feb-20"), (2020, 2, 3, 0, 0, 0.0))
     41        self.assertEqual(parse_date("03-Feb-20"), (2020, 2, 3, 0, 0, 0.0))
    3742
    3843        # this test will break around year 2048
    39         self.assertEquals(parse_date("03-Feb-98"), (1998, 2, 3, 0, 0, 0.0))
     44        self.assertEqual(parse_date("03-Feb-98"), (1998, 2, 3, 0, 0, 0.0))
    4045
    4146    def test_http2time_formats(self):
    … …  
    6772        result = time2isoz(test_t)
    6873        expected = "1994-02-03 00:00:00Z"
    69         self.assertEquals(result, expected,
    70                           "%s  =>  '%s' (%s)" % (test_t, result, expected))
     74        self.assertEqual(result, expected,
     75                         "%s  =>  '%s' (%s)" % (test_t, result, expected))
    7176
    7277        for s in tests:
    … …  
    7580            t3 = http2time(s.upper())
    7681
    77             self.assert_(t == t2 == t3 == test_t,
     82            self.assertTrue(t == t2 == t3 == test_t,
    7883                         "'%s'  =>  %s, %s, %s (%s)" % (s, t, t2, t3, test_t))
    7984
    … …  
    9398            '01-01-1980 00:00:62',
    9499            ]:
    95             self.assert_(http2time(test) is None,
     100            self.assertTrue(http2time(test) is None,
    96101                         "http2time(%s) is not None\n"
    97102                         "http2time(test) %s" % (test, http2time(test))
    … …  
    100105
    101106class HeaderTests(TestCase):
    102     def test_parse_ns_headers(self):
     107
     108    def test_parse_ns_headers_expires(self):
    103109        from cookielib import parse_ns_headers
    104110
    … …  
    109115            'foo=bar; expires="01 Jan 2040 22:23:32 GMT"',
    110116            ]:
    111             self.assertEquals(parse_ns_headers([hdr]), expected)
     117            self.assertEqual(parse_ns_headers([hdr]), expected)
     118
     119    def test_parse_ns_headers_version(self):
     120        from cookielib import parse_ns_headers
     121
     122        # quotes should be stripped
     123        expected = [[('foo', 'bar'), ('version', '1')]]
     124        for hdr in [
     125            'foo=bar; version="1"',
     126            'foo=bar; Version="1"',
     127            ]:
     128            self.assertEqual(parse_ns_headers([hdr]), expected)
    112129
    113130    def test_parse_ns_headers_special_names(self):
    … …  
    119136        hdr = 'expires=01 Jan 2040 22:23:32 GMT'
    120137        expected = [[("expires", "01 Jan 2040 22:23:32 GMT"), ("version", "0")]]
    121         self.assertEquals(parse_ns_headers([hdr]), expected)
     138        self.assertEqual(parse_ns_headers([hdr]), expected)
    122139
    123140    def test_join_header_words(self):
    … …  
    125142
    126143        joined = join_header_words([[("foo", None), ("bar", "baz")]])
    127         self.assertEquals(joined, "foo; bar=baz")
    128 
    129         self.assertEquals(join_header_words([[]]), "")
     144        self.assertEqual(joined, "foo; bar=baz")
     145
     146        self.assertEqual(join_header_words([[]]), "")
    130147
    131148    def test_split_header_words(self):
    … …  
    159176                traceback.print_exc(None, f)
    160177                result = "(error -- traceback follows)\n\n%s" % f.getvalue()
    161             self.assertEquals(result,  expect, """
     178            self.assertEqual(result,  expect, """
    162179When parsing: '%s'
    163180Expected:     '%s'
    … …  
    193210            input = split_header_words([arg])
    194211            res = join_header_words(input)
    195             self.assertEquals(res, expect, """
     212            self.assertEqual(res, expect, """
    196213When parsing: '%s'
    197214Expected:     '%s'
    … …  
    313330##   means that if you fold multiple Set-Cookie header fields into one,
    314331##   comma-separated list, it'll be a headache to parse (at least my head
    315 ##   starts hurting everytime I think of that code).
     332##   starts hurting every time I think of that code).
    316333## - Expires: You'll get all sorts of date formats in the expires,
    317334##   including emtpy expires attributes ("expires="). Be as flexible as you
    … …  
    350367            request = urllib2.Request(url)
    351368            r = pol.domain_return_ok(domain, request)
    352             if ok: self.assert_(r)
    353             else: self.assert_(not r)
     369            if ok: self.assertTrue(r)
     370            else: self.assertTrue(not r)
    354371
    355372    def test_missing_value(self):
    … …  
    363380        interact_netscape(c, "http://www.acme.com/", '"spam"; path=/foo/')
    364381        cookie = c._cookies["www.acme.com"]["/"]["eggs"]
    365         self.assert_(cookie.value is None)
    366         self.assertEquals(cookie.name, "eggs")
     382        self.assertTrue(cookie.value is None)
     383        self.assertEqual(cookie.name, "eggs")
    367384        cookie = c._cookies["www.acme.com"]['/foo/']['"spam"']
    368         self.assert_(cookie.value is None)
    369         self.assertEquals(cookie.name, '"spam"')
    370         self.assertEquals(lwp_cookie_str(cookie), (
     385        self.assertTrue(cookie.value is None)
     386        self.assertEqual(cookie.name, '"spam"')
     387        self.assertEqual(lwp_cookie_str(cookie), (
    371388            r'"spam"; path="/foo/"; domain="www.acme.com"; '
    372389            'path_spec; discard; version=0'))
    … …  
    379396            os.unlink(c.filename)
    380397        # cookies unchanged apart from lost info re. whether path was specified
    381         self.assertEquals(
     398        self.assertEqual(
    382399            repr(c),
    383400            re.sub("path_specified=%s" % True, "path_specified=%s" % False,
    384401                   old_str)
    385402            )
    386         self.assertEquals(interact_netscape(c, "http://www.acme.com/foo/"),
    387                           '"spam"; eggs')
     403        self.assertEqual(interact_netscape(c, "http://www.acme.com/foo/"),
     404                         '"spam"; eggs')
    388405
    389406    def test_rfc2109_handling(self):
    … …  
    410427                cookie = c._cookies["www.example.com"]["/"]["ni"]
    411428            except KeyError:
    412                 self.assert_(version is None)  # didn't expect a stored cookie
     429                self.assertTrue(version is None)  # didn't expect a stored cookie
    413430            else:
    414431                self.assertEqual(cookie.version, version)
    … …  
    433450
    434451        cookie = c._cookies[".acme.com"]["/"]["spam"]
    435         self.assertEquals(cookie.domain, ".acme.com")
    436         self.assert_(cookie.domain_specified)
    437         self.assertEquals(cookie.port, DEFAULT_HTTP_PORT)
    438         self.assert_(not cookie.port_specified)
     452        self.assertEqual(cookie.domain, ".acme.com")
     453        self.assertTrue(cookie.domain_specified)
     454        self.assertEqual(cookie.port, DEFAULT_HTTP_PORT)
     455        self.assertTrue(not cookie.port_specified)
    439456        # case is preserved
    440         self.assert_(cookie.has_nonstandard_attr("blArgh") and
     457        self.assertTrue(cookie.has_nonstandard_attr("blArgh") and
    441458                     not cookie.has_nonstandard_attr("blargh"))
    442459
    443460        cookie = c._cookies["www.acme.com"]["/"]["ni"]
    444         self.assertEquals(cookie.domain, "www.acme.com")
    445         self.assert_(not cookie.domain_specified)
    446         self.assertEquals(cookie.port, "80,8080")
    447         self.assert_(cookie.port_specified)
     461        self.assertEqual(cookie.domain, "www.acme.com")
     462        self.assertTrue(not cookie.domain_specified)
     463        self.assertEqual(cookie.port, "80,8080")
     464        self.assertTrue(cookie.port_specified)
    448465
    449466        cookie = c._cookies["www.acme.com"]["/"]["nini"]
    450         self.assert_(cookie.port is None)
    451         self.assert_(not cookie.port_specified)
     467        self.assertTrue(cookie.port is None)
     468        self.assertTrue(not cookie.port_specified)
    452469
    453470        # invalid expires should not cause cookie to be dropped
    454471        foo = c._cookies["www.acme.com"]["/"]["foo"]
    455472        spam = c._cookies["www.acme.com"]["/"]["foo"]
    456         self.assert_(foo.expires is None)
    457         self.assert_(spam.expires is None)
     473        self.assertTrue(foo.expires is None)
     474        self.assertTrue(spam.expires is None)
    458475
    459476    def test_ns_parser_special_names(self):
    … …  
    467484
    468485        cookies = c._cookies["www.acme.com"]["/"]
    469         self.assert_('expires' in cookies)
    470         self.assert_('version' in cookies)
     486        self.assertTrue('expires' in cookies)
     487        self.assertTrue('version' in cookies)
    471488
    472489    def test_expires(self):
    … …  
    478495        interact_netscape(c, "http://www.acme.com/", 'spam="bar"; expires=%s' %
    479496                          future)
    480         self.assertEquals(len(c), 1)
     497        self.assertEqual(len(c), 1)
    481498        now = time2netscape(time.time()-1)
    482499        # ... and if in past or present, discard it
    … …  
    484501                          now)
    485502        h = interact_netscape(c, "http://www.acme.com/")
    486         self.assertEquals(len(c), 1)
    487         self.assert_('spam="bar"' in h and "foo" not in h)
     503        self.assertEqual(len(c), 1)
     504        self.assertTrue('spam="bar"' in h and "foo" not in h)
    488505
    489506        # max-age takes precedence over expires, and zero max-age is request to
    … …  
    493510        interact_netscape(c, "http://www.acme.com/", 'bar="bar"; expires=%s' %
    494511                          future)
    495         self.assertEquals(len(c), 3)
     512        self.assertEqual(len(c), 3)
    496513        interact_netscape(c, "http://www.acme.com/", 'eggs="bar"; '
    497514                          'expires=%s; max-age=0' % future)
    … …  
    499516                          'max-age=0; expires=%s' % future)
    500517        h = interact_netscape(c, "http://www.acme.com/")
    501         self.assertEquals(len(c), 1)
     518        self.assertEqual(len(c), 1)
    502519
    503520        # test expiry at end of session for cookies with no expires attribute
    504521        interact_netscape(c, "http://www.rhubarb.net/", 'whum="fizz"')
    505         self.assertEquals(len(c), 2)
     522        self.assertEqual(len(c), 2)
    506523        c.clear_session_cookies()
    507         self.assertEquals(len(c), 1)
    508         self.assert_('spam="bar"' in h)
     524        self.assertEqual(len(c), 1)
     525        self.assertIn('spam="bar"', h)
    509526
    510527        # XXX RFC 2965 expiry rules (some apply to V0 too)
    … …  
    518535        c = CookieJar(pol)
    519536        interact_2965(c, "http://www.acme.com/", 'spam="bar"; Version="1"')
    520         self.assert_("/" in c._cookies["www.acme.com"])
     537        self.assertIn("/", c._cookies["www.acme.com"])
    521538
    522539        c = CookieJar(pol)
    523540        interact_2965(c, "http://www.acme.com/blah", 'eggs="bar"; Version="1"')
    524         self.assert_("/" in c._cookies["www.acme.com"])
     541        self.assertIn("/", c._cookies["www.acme.com"])
    525542
    526543        c = CookieJar(pol)
    527544        interact_2965(c, "http://www.acme.com/blah/rhubarb",
    528545                      'eggs="bar"; Version="1"')
    529         self.assert_("/blah/" in c._cookies["www.acme.com"])
     546        self.assertIn("/blah/", c._cookies["www.acme.com"])
    530547
    531548        c = CookieJar(pol)
    532549        interact_2965(c, "http://www.acme.com/blah/rhubarb/",
    533550                      'eggs="bar"; Version="1"')
    534         self.assert_("/blah/rhubarb/" in c._cookies["www.acme.com"])
     551        self.assertIn("/blah/rhubarb/", c._cookies["www.acme.com"])
    535552
    536553        # Netscape
    … …  
    538555        c = CookieJar()
    539556        interact_netscape(c, "http://www.acme.com/", 'spam="bar"')
    540         self.assert_("/" in c._cookies["www.acme.com"])
     557        self.assertIn("/", c._cookies["www.acme.com"])
    541558
    542559        c = CookieJar()
    543560        interact_netscape(c, "http://www.acme.com/blah", 'eggs="bar"')
    544         self.assert_("/" in c._cookies["www.acme.com"])
     561        self.assertIn("/", c._cookies["www.acme.com"])
    545562
    546563        c = CookieJar()
    547564        interact_netscape(c, "http://www.acme.com/blah/rhubarb", 'eggs="bar"')
    548         self.assert_("/blah" in c._cookies["www.acme.com"])
     565        self.assertIn("/blah", c._cookies["www.acme.com"])
    549566
    550567        c = CookieJar()
    551568        interact_netscape(c, "http://www.acme.com/blah/rhubarb/", 'eggs="bar"')
    552         self.assert_("/blah/rhubarb" in c._cookies["www.acme.com"])
     569        self.assertIn("/blah/rhubarb", c._cookies["www.acme.com"])
     570
     571    def test_default_path_with_query(self):
     572        cj = cookielib.CookieJar()
     573        uri = "http://example.com/?spam/eggs"
     574        value = 'eggs="bar"'
     575        interact_netscape(cj, uri, value)
     576        # default path does not include query, so is "/", not "/?spam"
     577        self.assertIn("/", cj._cookies["example.com"])
     578        # cookie is sent back to the same URI
     579        self.assertEqual(interact_netscape(cj, uri), value)
    553580
    554581    def test_escape_path(self):
    … …  
    574601            ]
    575602        for arg, result in cases:
    576             self.assertEquals(escape_path(arg), result)
     603            self.assertEqual(escape_path(arg), result)
    577604
    578605    def test_request_path(self):
    … …  
    580607        from cookielib import request_path
    581608        # with parameters
    582         req = Request("http://www.example.com/rheum/rhaponicum;"
     609        req = Request("http://www.example.com/rheum/rhaponticum;"
    583610                      "foo=bar;sing=song?apples=pears&spam=eggs#ni")
    584         self.assertEquals(request_path(req), "/rheum/rhaponicum;"
    585                      "foo=bar;sing=song?apples=pears&spam=eggs#ni")
     611        self.assertEqual(request_path(req),
     612                         "/rheum/rhaponticum;foo=bar;sing=song")
    586613        # without parameters
    587         req = Request("http://www.example.com/rheum/rhaponicum?"
     614        req = Request("http://www.example.com/rheum/rhaponticum?"
    588615                      "apples=pears&spam=eggs#ni")
    589         self.assertEquals(request_path(req), "/rheum/rhaponicum?"
    590                      "apples=pears&spam=eggs#ni")
     616        self.assertEqual(request_path(req), "/rheum/rhaponticum")
    591617        # missing final slash
    592618        req = Request("http://www.example.com")
    593         self.assertEquals(request_path(req), "/")
     619        self.assertEqual(request_path(req), "/")
    594620
    595621    def test_request_port(self):
    … …  
    598624        req = Request("http://www.acme.com:1234/",
    599625                      headers={"Host": "www.acme.com:4321"})
    600         self.assertEquals(request_port(req), "1234")
     626        self.assertEqual(request_port(req), "1234")
    601627        req = Request("http://www.acme.com/",
    602628                      headers={"Host": "www.acme.com:4321"})
    603         self.assertEquals(request_port(req), DEFAULT_HTTP_PORT)
     629        self.assertEqual(request_port(req), DEFAULT_HTTP_PORT)
    604630
    605631    def test_request_host(self):
    … …  
    611637        # libwww-perl wants this response, but that seems wrong (RFC 2616,
    612638        # section 5.2, point 1., and RFC 2965 section 1, paragraph 3)
    613         #self.assertEquals(request_host(req), "www.acme.com")
    614         self.assertEquals(request_host(req), "1.1.1.1")
     639        #self.assertEqual(request_host(req), "www.acme.com")
     640        self.assertEqual(request_host(req), "1.1.1.1")
    615641        req = Request("http://www.acme.com/",
    616642                      headers={"Host": "irrelevant.com"})
    617         self.assertEquals(request_host(req), "www.acme.com")
     643        self.assertEqual(request_host(req), "www.acme.com")
    618644        # not actually sure this one is valid Request object, so maybe should
    619645        # remove test for no host in url in request_host function?
    620646        req = Request("/resource.html",
    621647                      headers={"Host": "www.acme.com"})
    622         self.assertEquals(request_host(req), "www.acme.com")
     648        self.assertEqual(request_host(req), "www.acme.com")
    623649        # port shouldn't be in request-host
    624650        req = Request("http://www.acme.com:2345/resource.html",
    625651                      headers={"Host": "www.acme.com:5432"})
    626         self.assertEquals(request_host(req), "www.acme.com")
     652        self.assertEqual(request_host(req), "www.acme.com")
    627653
    628654    def test_is_HDN(self):
    629655        from cookielib import is_HDN
    630         self.assert_(is_HDN("foo.bar.com"))
    631         self.assert_(is_HDN("1foo2.3bar4.5com"))
    632         self.assert_(not is_HDN("192.168.1.1"))
    633         self.assert_(not is_HDN(""))
    634         self.assert_(not is_HDN("."))
    635         self.assert_(not is_HDN(".foo.bar.com"))
    636         self.assert_(not is_HDN("..foo"))
    637         self.assert_(not is_HDN("foo."))
     656        self.assertTrue(is_HDN("foo.bar.com"))
     657        self.assertTrue(is_HDN("1foo2.3bar4.5com"))
     658        self.assertTrue(not is_HDN("192.168.1.1"))
     659        self.assertTrue(not is_HDN(""))
     660        self.assertTrue(not is_HDN("."))
     661        self.assertTrue(not is_HDN(".foo.bar.com"))
     662        self.assertTrue(not is_HDN("..foo"))
     663        self.assertTrue(not is_HDN("foo."))
    638664
    639665    def test_reach(self):
    640666        from cookielib import reach
    641         self.assertEquals(reach("www.acme.com"), ".acme.com")
    642         self.assertEquals(reach("acme.com"), "acme.com")
    643         self.assertEquals(reach("acme.local"), ".local")
    644         self.assertEquals(reach(".local"), ".local")
    645         self.assertEquals(reach(".com"), ".com")
    646         self.assertEquals(reach("."), ".")
    647         self.assertEquals(reach(""), "")
    648         self.assertEquals(reach("192.168.0.1"), "192.168.0.1")
     667        self.assertEqual(reach("www.acme.com"), ".acme.com")
     668        self.assertEqual(reach("acme.com"), "acme.com")
     669        self.assertEqual(reach("acme.local"), ".local")
     670        self.assertEqual(reach(".local"), ".local")
     671        self.assertEqual(reach(".com"), ".com")
     672        self.assertEqual(reach("."), ".")
     673        self.assertEqual(reach(""), "")
     674        self.assertEqual(reach("192.168.0.1"), "192.168.0.1")
    649675
    650676    def test_domain_match(self):
    651677        from cookielib import domain_match, user_domain_match
    652         self.assert_(domain_match("192.168.1.1", "192.168.1.1"))
    653         self.assert_(not domain_match("192.168.1.1", ".168.1.1"))
    654         self.assert_(domain_match("x.y.com", "x.Y.com"))
    655         self.assert_(domain_match("x.y.com", ".Y.com"))
    656         self.assert_(not domain_match("x.y.com", "Y.com"))
    657         self.assert_(domain_match("a.b.c.com", ".c.com"))
    658         self.assert_(not domain_match(".c.com", "a.b.c.com"))
    659         self.assert_(domain_match("example.local", ".local"))
    660         self.assert_(not domain_match("blah.blah", ""))
    661         self.assert_(not domain_match("", ".rhubarb.rhubarb"))
    662         self.assert_(domain_match("", ""))
    663 
    664         self.assert_(user_domain_match("acme.com", "acme.com"))
    665         self.assert_(not user_domain_match("acme.com", ".acme.com"))
    666         self.assert_(user_domain_match("rhubarb.acme.com", ".acme.com"))
    667         self.assert_(user_domain_match("www.rhubarb.acme.com", ".acme.com"))
    668         self.assert_(user_domain_match("x.y.com", "x.Y.com"))
    669         self.assert_(user_domain_match("x.y.com", ".Y.com"))
    670         self.assert_(not user_domain_match("x.y.com", "Y.com"))
    671         self.assert_(user_domain_match("y.com", "Y.com"))
    672         self.assert_(not user_domain_match(".y.com", "Y.com"))
    673         self.assert_(user_domain_match(".y.com", ".Y.com"))
    674         self.assert_(user_domain_match("x.y.com", ".com"))
    675         self.assert_(not user_domain_match("x.y.com", "com"))
    676         self.assert_(not user_domain_match("x.y.com", "m"))
    677         self.assert_(not user_domain_match("x.y.com", ".m"))
    678         self.assert_(not user_domain_match("x.y.com", ""))
    679         self.assert_(not user_domain_match("x.y.com", "."))
    680         self.assert_(user_domain_match("192.168.1.1", "192.168.1.1"))
     678        self.assertTrue(domain_match("192.168.1.1", "192.168.1.1"))
     679        self.assertTrue(not domain_match("192.168.1.1", ".168.1.1"))
     680        self.assertTrue(domain_match("x.y.com", "x.Y.com"))
     681        self.assertTrue(domain_match("x.y.com", ".Y.com"))
     682        self.assertTrue(not domain_match("x.y.com", "Y.com"))
     683        self.assertTrue(domain_match("a.b.c.com", ".c.com"))
     684        self.assertTrue(not domain_match(".c.com", "a.b.c.com"))
     685        self.assertTrue(domain_match("example.local", ".local"))
     686        self.assertTrue(not domain_match("blah.blah", ""))
     687        self.assertTrue(not domain_match("", ".rhubarb.rhubarb"))
     688        self.assertTrue(domain_match("", ""))
     689
     690        self.assertTrue(user_domain_match("acme.com", "acme.com"))
     691        self.assertTrue(not user_domain_match("acme.com", ".acme.com"))
     692        self.assertTrue(user_domain_match("rhubarb.acme.com", ".acme.com"))
     693        self.assertTrue(user_domain_match("www.rhubarb.acme.com", ".acme.com"))
     694        self.assertTrue(user_domain_match("x.y.com", "x.Y.com"))
     695        self.assertTrue(user_domain_match("x.y.com", ".Y.com"))
     696        self.assertTrue(not user_domain_match("x.y.com", "Y.com"))
     697        self.assertTrue(user_domain_match("y.com", "Y.com"))
     698        self.assertTrue(not user_domain_match(".y.com", "Y.com"))
     699        self.assertTrue(user_domain_match(".y.com", ".Y.com"))
     700        self.assertTrue(user_domain_match("x.y.com", ".com"))
     701        self.assertTrue(not user_domain_match("x.y.com", "com"))
     702        self.assertTrue(not user_domain_match("x.y.com", "m"))
     703        self.assertTrue(not user_domain_match("x.y.com", ".m"))
     704        self.assertTrue(not user_domain_match("x.y.com", ""))
     705        self.assertTrue(not user_domain_match("x.y.com", "."))
     706        self.assertTrue(user_domain_match("192.168.1.1", "192.168.1.1"))
    681707        # not both HDNs, so must string-compare equal to match
    682         self.assert_(not user_domain_match("192.168.1.1", ".168.1.1"))
    683         self.assert_(not user_domain_match("192.168.1.1", "."))
     708        self.assertTrue(not user_domain_match("192.168.1.1", ".168.1.1"))
     709        self.assertTrue(not user_domain_match("192.168.1.1", "."))
    684710        # empty string is a special case
    685         self.assert_(not user_domain_match("192.168.1.1", ""))
     711        self.assertTrue(not user_domain_match("192.168.1.1", ""))
    686712
    687713    def test_wrong_domain(self):
    … …  
    694720        interact_2965(c, "http://www.nasty.com/",
    695721                      'foo=bar; domain=friendly.org; Version="1"')
    696         self.assertEquals(len(c), 0)
     722        self.assertEqual(len(c), 0)
    697723
    698724    def test_strict_domain(self):
    … …  
    706732        interact_netscape(cj, "http://example.co.uk/",
    707733                          'okey=dokey; Domain=.example.co.uk')
    708         self.assertEquals(len(cj), 2)
     734        self.assertEqual(len(cj), 2)
    709735        for pseudo_tld in [".co.uk", ".org.za", ".tx.us", ".name.us"]:
    710736            interact_netscape(cj, "http://example.%s/" % pseudo_tld,
    711737                              'spam=eggs; Domain=.co.uk')
    712             self.assertEquals(len(cj), 2)
     738            self.assertEqual(len(cj), 2)
    713739
    714740    def test_two_component_domain_ns(self):
    … …  
    722748        # two-component V0 domain is OK
    723749        interact_netscape(c, "http://foo.net/", 'ns=bar')
    724         self.assertEquals(len(c), 1)
    725         self.assertEquals(c._cookies["foo.net"]["/"]["ns"].value, "bar")
    726         self.assertEquals(interact_netscape(c, "http://foo.net/"), "ns=bar")
     750        self.assertEqual(len(c), 1)
     751        self.assertEqual(c._cookies["foo.net"]["/"]["ns"].value, "bar")
     752        self.assertEqual(interact_netscape(c, "http://foo.net/"), "ns=bar")
    727753        # *will* be returned to any other domain (unlike RFC 2965)...
    728         self.assertEquals(interact_netscape(c, "http://www.foo.net/"),
    729                           "ns=bar")
     754        self.assertEqual(interact_netscape(c, "http://www.foo.net/"),
     755                         "ns=bar")
    730756        # ...unless requested otherwise
    731757        pol = DefaultCookiePolicy(
    732758            strict_ns_domain=DefaultCookiePolicy.DomainStrictNonDomain)
    733759        c.set_policy(pol)
    734         self.assertEquals(interact_netscape(c, "http://www.foo.net/"), "")
     760        self.assertEqual(interact_netscape(c, "http://www.foo.net/"), "")
    735761
    736762        # unlike RFC 2965, even explicit two-component domain is OK,
    … …  
    741767        interact_netscape(c, "http://foo.net/foo/bar/",
    742768                          'spam2=eggs; domain=.foo.net')
    743         self.assertEquals(len(c), 3)
    744         self.assertEquals(c._cookies[".foo.net"]["/foo"]["spam1"].value,
    745                           "eggs")
    746         self.assertEquals(c._cookies[".foo.net"]["/foo/bar"]["spam2"].value,
    747                           "eggs")
    748         self.assertEquals(interact_netscape(c, "http://foo.net/foo/bar/"),
    749                           "spam2=eggs; spam1=eggs; ns=bar")
     769        self.assertEqual(len(c), 3)
     770        self.assertEqual(c._cookies[".foo.net"]["/foo"]["spam1"].value,
     771                         "eggs")
     772        self.assertEqual(c._cookies[".foo.net"]["/foo/bar"]["spam2"].value,
     773                         "eggs")
     774        self.assertEqual(interact_netscape(c, "http://foo.net/foo/bar/"),
     775                         "spam2=eggs; spam1=eggs; ns=bar")
    750776
    751777        # top-level domain is too general
    752778        interact_netscape(c, "http://foo.net/", 'nini="ni"; domain=.net')
    753         self.assertEquals(len(c), 3)
     779        self.assertEqual(len(c), 3)
    754780
    755781##         # Netscape protocol doesn't allow non-special top level domains (such
    … …  
    759785        # cookies (of course) rely on that behaviour.
    760786        interact_netscape(c, "http://foo.co.uk", 'nasty=trick; domain=.co.uk')
    761 ##         self.assertEquals(len(c), 2)
    762         self.assertEquals(len(c), 4)
     787##         self.assertEqual(len(c), 2)
     788        self.assertEqual(len(c), 4)
    763789
    764790    def test_two_component_domain_rfc2965(self):
    … …  
    770796        # two-component V1 domain is OK
    771797        interact_2965(c, "http://foo.net/", 'foo=bar; Version="1"')
    772         self.assertEquals(len(c), 1)
    773         self.assertEquals(c._cookies["foo.net"]["/"]["foo"].value, "bar")
    774         self.assertEquals(interact_2965(c, "http://foo.net/"),
    775                           "$Version=1; foo=bar")
     798        self.assertEqual(len(c), 1)
     799        self.assertEqual(c._cookies["foo.net"]["/"]["foo"].value, "bar")
     800        self.assertEqual(interact_2965(c, "http://foo.net/"),
     801                         "$Version=1; foo=bar")
    776802        # won't be returned to any other domain (because domain was implied)
    777         self.assertEquals(interact_2965(c, "http://www.foo.net/"), "")
     803        self.assertEqual(interact_2965(c, "http://www.foo.net/"), "")
    778804
    779805        # unless domain is given explicitly, because then it must be
    … …  
    782808        interact_2965(c, "http://foo.net/foo",
    783809                      'spam=eggs; domain=foo.net; path=/foo; Version="1"')
    784         self.assertEquals(len(c), 1)
    785         self.assertEquals(interact_2965(c, "http://foo.net/foo"),
    786                           "$Version=1; foo=bar")
     810        self.assertEqual(len(c), 1)
     811        self.assertEqual(interact_2965(c, "http://foo.net/foo"),
     812                         "$Version=1; foo=bar")
    787813
    788814        # explicit foo.net from three-component domain www.foo.net *does* get
    … …  
    790816        interact_2965(c, "http://www.foo.net/foo/",
    791817                      'spam=eggs; domain=foo.net; Version="1"')
    792         self.assertEquals(c._cookies[".foo.net"]["/foo/"]["spam"].value,
    793                           "eggs")
    794         self.assertEquals(len(c), 2)
    795         self.assertEquals(interact_2965(c, "http://foo.net/foo/"),
    796                           "$Version=1; foo=bar")
    797         self.assertEquals(interact_2965(c, "http://www.foo.net/foo/"),
    798                           '$Version=1; spam=eggs; $Domain="foo.net"')
     818        self.assertEqual(c._cookies[".foo.net"]["/foo/"]["spam"].value,
     819                         "eggs")
     820        self.assertEqual(len(c), 2)
     821        self.assertEqual(interact_2965(c, "http://foo.net/foo/"),
     822                         "$Version=1; foo=bar")
     823        self.assertEqual(interact_2965(c, "http://www.foo.net/foo/"),
     824                         '$Version=1; spam=eggs; $Domain="foo.net"')
    799825
    800826        # top-level domain is too general
    801827        interact_2965(c, "http://foo.net/",
    802828                      'ni="ni"; domain=".net"; Version="1"')
    803         self.assertEquals(len(c), 2)
     829        self.assertEqual(len(c), 2)
    804830
    805831        # RFC 2965 doesn't require blocking this
    806832        interact_2965(c, "http://foo.co.uk/",
    807833                      'nasty=trick; domain=.co.uk; Version="1"')
    808         self.assertEquals(len(c), 3)
     834        self.assertEqual(len(c), 3)
    809835
    810836    def test_domain_allow(self):
    … …  
    820846        res = FakeResponse(headers, "http://acme.com/")
    821847        c.extract_cookies(res, req)
    822         self.assertEquals(len(c), 0)
     848        self.assertEqual(len(c), 0)
    823849
    824850        req = Request("http://www.acme.com/")
    825851        res = FakeResponse(headers, "http://www.acme.com/")
    826852        c.extract_cookies(res, req)
    827         self.assertEquals(len(c), 1)
     853        self.assertEqual(len(c), 1)
    828854
    829855        req = Request("http://www.coyote.com/")
    830856        res = FakeResponse(headers, "http://www.coyote.com/")
    831857        c.extract_cookies(res, req)
    832         self.assertEquals(len(c), 1)
     858        self.assertEqual(len(c), 1)
    833859
    834860        # set a cookie with non-allowed domain...
    … …  
    837863        cookies = c.make_cookies(res, req)
    838864        c.set_cookie(cookies[0])
    839         self.assertEquals(len(c), 2)
     865        self.assertEqual(len(c), 2)
    840866        # ... and check is doesn't get returned
    841867        c.add_cookie_header(req)
    842         self.assert_(not req.has_header("Cookie"))
     868        self.assertTrue(not req.has_header("Cookie"))
    843869
    844870    def test_domain_block(self):
    … …  
    854880        res = FakeResponse(headers, "http://www.acme.com/")
    855881        c.extract_cookies(res, req)
    856         self.assertEquals(len(c), 0)
     882        self.assertEqual(len(c), 0)
    857883
    858884        p = pol.set_blocked_domains(["acme.com"])
    859885        c.extract_cookies(res, req)
    860         self.assertEquals(len(c), 1)
     886        self.assertEqual(len(c), 1)
    861887
    862888        c.clear()
    … …  
    864890        res = FakeResponse(headers, "http://www.roadrunner.net/")
    865891        c.extract_cookies(res, req)
    866         self.assertEquals(len(c), 1)
     892        self.assertEqual(len(c), 1)
    867893        req = Request("http://www.roadrunner.net/")
    868894        c.add_cookie_header(req)
    869         self.assert_((req.has_header("Cookie") and
     895        self.assertTrue((req.has_header("Cookie") and
    870896                      req.has_header("Cookie2")))
    871897
    … …  
    873899        pol.set_blocked_domains([".acme.com"])
    874900        c.extract_cookies(res, req)
    875         self.assertEquals(len(c), 1)
     901        self.assertEqual(len(c), 1)
    876902
    877903        # set a cookie with blocked domain...
    … …  
    880906        cookies = c.make_cookies(res, req)
    881907        c.set_cookie(cookies[0])
    882         self.assertEquals(len(c), 2)
     908        self.assertEqual(len(c), 2)
    883909        # ... and check is doesn't get returned
    884910        c.add_cookie_header(req)
    885         self.assert_(not req.has_header("Cookie"))
     911        self.assertTrue(not req.has_header("Cookie"))
    886912
    887913    def test_secure(self):
    … …  
    903929                int(c, url, "foo1=bar%s%s" % (vs, whitespace))
    904930                int(c, url, "foo2=bar%s; secure%s" %  (vs, whitespace))
    905                 self.assert_(
     931                self.assertTrue(
    906932                    not c._cookies["www.acme.com"]["/"]["foo1"].secure,
    907933                    "non-secure cookie registered secure")
    908                 self.assert_(
     934                self.assertTrue(
    909935                    c._cookies["www.acme.com"]["/"]["foo2"].secure,
    910936                    "secure cookie registered non-secure")
    … …  
    915941        interact_2965(c, "http://www.acme.com/", r'foo=\b"a"r; Version=1')
    916942        h = interact_2965(c, "http://www.acme.com/")
    917         self.assertEquals(h, r'$Version=1; foo=\\b\"a\"r')
     943        self.assertEqual(h, r'$Version=1; foo=\\b\"a\"r')
    918944
    919945    def test_missing_final_slash(self):
    … …  
    925951        interact_2965(c, url, "foo=bar; Version=1")
    926952        req = Request(url)
    927         self.assertEquals(len(c), 1)
     953        self.assertEqual(len(c), 1)
    928954        c.add_cookie_header(req)
    929         self.assert_(req.has_header("Cookie"))
     955        self.assertTrue(req.has_header("Cookie"))
    930956
    931957    def test_domain_mirror(self):
    … …  
    938964        interact_2965(c, url, "spam=eggs; Version=1")
    939965        h = interact_2965(c, url)
    940         self.assert_("Domain" not in h,
    941                      "absent domain returned with domain present")
     966        self.assertNotIn("Domain", h,
     967                         "absent domain returned with domain present")
    942968
    943969        c = CookieJar(pol)
    … …  
    945971        interact_2965(c, url, 'spam=eggs; Version=1; Domain=.bar.com')
    946972        h = interact_2965(c, url)
    947         self.assert_('$Domain=".bar.com"' in h, "domain not returned")
     973        self.assertIn('$Domain=".bar.com"', h, "domain not returned")
    948974
    949975        c = CookieJar(pol)
    … …  
    952978        interact_2965(c, url, 'spam=eggs; Version=1; Domain=bar.com')
    953979        h = interact_2965(c, url)
    954         self.assert_('$Domain="bar.com"' in h, "domain not returned")
     980        self.assertIn('$Domain="bar.com"', h, "domain not returned")
    955981
    956982    def test_path_mirror(self):
    … …  
    963989        interact_2965(c, url, "spam=eggs; Version=1")
    964990        h = interact_2965(c, url)
    965         self.assert_("Path" not in h,
    966                      "absent path returned with path present")
     991        self.assertNotIn("Path", h, "absent path returned with path present")
    967992
    968993        c = CookieJar(pol)
    … …  
    970995        interact_2965(c, url, 'spam=eggs; Version=1; Path=/')
    971996        h = interact_2965(c, url)
    972         self.assert_('$Path="/"' in h, "path not returned")
     997        self.assertIn('$Path="/"', h, "path not returned")
    973998
    974999    def test_port_mirror(self):
    … …  
    9811006        interact_2965(c, url, "spam=eggs; Version=1")
    9821007        h = interact_2965(c, url)
    983         self.assert_("Port" not in h,
    984                      "absent port returned with port present")
     1008        self.assertNotIn("Port", h, "absent port returned with port present")
    9851009
    9861010        c = CookieJar(pol)
    … …  
    9881012        interact_2965(c, url, "spam=eggs; Version=1; Port")
    9891013        h = interact_2965(c, url)
    990         self.assert_(re.search("\$Port([^=]|$)", h),
     1014        self.assertTrue(re.search("\$Port([^=]|$)", h),
    9911015                     "port with no value not returned with no value")
    9921016
    … …  
    9951019        interact_2965(c, url, 'spam=eggs; Version=1; Port="80"')
    9961020        h = interact_2965(c, url)
    997         self.assert_('$Port="80"' in h,
    998                      "port with single value not returned with single value")
     1021        self.assertIn('$Port="80"', h,
     1022                      "port with single value not returned with single value")
    9991023
    10001024        c = CookieJar(pol)
    … …  
    10021026        interact_2965(c, url, 'spam=eggs; Version=1; Port="80,8080"')
    10031027        h = interact_2965(c, url)
    1004         self.assert_('$Port="80,8080"' in h,
    1005                      "port with multiple values not returned with multiple "
    1006                      "values")
     1028        self.assertIn('$Port="80,8080"', h,
     1029                      "port with multiple values not returned with multiple "
     1030                      "values")
    10071031
    10081032    def test_no_return_comment(self):
    … …  
    10151039                      'CommentURL="http://foo.bar.net/comment.html"')
    10161040        h = interact_2965(c, url)
    1017         self.assert_(
     1041        self.assertTrue(
    10181042            "Comment" not in h,
    10191043            "Comment or CommentURL cookie-attributes returned to server")
    … …  
    10461070            i = 0
    10471071            for c in cs:
    1048                 self.assert_(isinstance(c, Cookie))
    1049                 self.assertEquals(c.version, versions[i])
    1050                 self.assertEquals(c.name, names[i])
    1051                 self.assertEquals(c.domain, domains[i])
    1052                 self.assertEquals(c.path, paths[i])
     1072                self.assertIsInstance(c, Cookie)
     1073                self.assertEqual(c.version, versions[i])
     1074                self.assertEqual(c.name, names[i])
     1075                self.assertEqual(c.domain, domains[i])
     1076                self.assertEqual(c.path, paths[i])
    10531077                i = i + 1
    10541078
    … …  
    10571081
    10581082        # missing domain value (invalid cookie)
    1059         self.assertEquals(
     1083        self.assertEqual(
    10601084            parse_ns_headers(["foo=bar; path=/; domain"]),
    10611085            [[("foo", "bar"),
    … …  
    10631087            )
    10641088        # invalid expires value
    1065         self.assertEquals(
     1089        self.assertEqual(
    10661090            parse_ns_headers(["foo=bar; expires=Foo Bar 12 33:22:11 2000"]),
    10671091            [[("foo", "bar"), ("expires", None), ("version", "0")]]
    10681092            )
    10691093        # missing cookie value (valid cookie)
    1070         self.assertEquals(
     1094        self.assertEqual(
    10711095            parse_ns_headers(["foo"]),
    10721096            [[("foo", None), ("version", "0")]]
    10731097            )
    10741098        # shouldn't add version if header is empty
    1075         self.assertEquals(parse_ns_headers([""]), [])
     1099        self.assertEqual(parse_ns_headers([""]), [])
    10761100
    10771101    def test_bad_cookie_header(self):
    … …  
    10941118            # bad max-age
    10951119            ["Set-Cookie: b=foo; max-age=oops"],
     1120            # bad version
     1121            ["Set-Cookie: b=foo; version=spam"],
    10961122            ]:
    10971123            c = cookiejar_from_cookie_headers(headers)
    10981124            # these bad cookies shouldn't be set
    1099             self.assertEquals(len(c), 0)
     1125            self.assertEqual(len(c), 0)
    11001126
    11011127        # cookie with invalid expires is treated as session cookie
    … …  
    11031129        c = cookiejar_from_cookie_headers(headers)
    11041130        cookie = c._cookies["www.example.com"]["/"]["c"]
    1105         self.assert_(cookie.expires is None)
     1131        self.assertTrue(cookie.expires is None)
    11061132
    11071133
    … …  
    11801206
    11811207        h = req.get_header("Cookie")
    1182         self.assert_("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and
    1183                      "CUSTOMER=WILE_E_COYOTE" in h)
     1208        self.assertIn("PART_NUMBER=ROCKET_LAUNCHER_0001", h)
     1209        self.assertIn("CUSTOMER=WILE_E_COYOTE", h)
    11841210
    11851211        headers.append('Set-Cookie: SHIPPING=FEDEX; path=/foo')
    … …  
    11911217
    11921218        h = req.get_header("Cookie")
    1193         self.assert_("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and
    1194                      "CUSTOMER=WILE_E_COYOTE" in h and
    1195                      "SHIPPING=FEDEX" not in h)
     1219        self.assertIn("PART_NUMBER=ROCKET_LAUNCHER_0001", h)
     1220        self.assertIn("CUSTOMER=WILE_E_COYOTE", h)
     1221        self.assertNotIn("SHIPPING=FEDEX", h)
    11961222
    11971223        req = Request("http://www.acme.com/foo/")
    … …  
    11991225
    12001226        h = req.get_header("Cookie")
    1201         self.assert_(("PART_NUMBER=ROCKET_LAUNCHER_0001" in h and
    1202                       "CUSTOMER=WILE_E_COYOTE" in h and
    1203                       h.startswith("SHIPPING=FEDEX;")))
     1227        self.assertIn("PART_NUMBER=ROCKET_LAUNCHER_0001", h)
     1228        self.assertIn("CUSTOMER=WILE_E_COYOTE", h)
     1229        self.assertTrue(h.startswith("SHIPPING=FEDEX;"))
    12041230
    12051231    def test_netscape_example_2(self):
    … …  
    12421268        c.add_cookie_header(req)
    12431269
    1244         self.assertEquals(req.get_header("Cookie"),
     1270        self.assertEqual(req.get_header("Cookie"),
    12451271                          "PART_NUMBER=ROCKET_LAUNCHER_0001")
    12461272
    … …  
    12531279        c.add_cookie_header(req)
    12541280
    1255         self.assert_(re.search(r"PART_NUMBER=RIDING_ROCKET_0023;\s*"
     1281        self.assertTrue(re.search(r"PART_NUMBER=RIDING_ROCKET_0023;\s*"
    12561282                               "PART_NUMBER=ROCKET_LAUNCHER_0001",
    12571283                               req.get_header("Cookie")))
    … …  
    12891315            c, 'http://www.acme.com/acme/login',
    12901316            'Customer="WILE_E_COYOTE"; Version="1"; Path="/acme"')
    1291         self.assert_(not cookie)
     1317        self.assertTrue(not cookie)
    12921318
    12931319        #
    … …  
    13111337                               'Part_Number="Rocket_Launcher_0001"; '
    13121338                               'Version="1"; Path="/acme"');
    1313         self.assert_(re.search(
     1339        self.assertTrue(re.search(
    13141340            r'^\$Version="?1"?; Customer="?WILE_E_COYOTE"?; \$Path="/acme"$',
    13151341            cookie))
    … …  
    13361362                               'Shipping="FedEx"; Version="1"; Path="/acme"')
    13371363
    1338         self.assert_(re.search(r'^\$Version="?1"?;', cookie))
    1339         self.assert_(re.search(r'Part_Number="?Rocket_Launcher_0001"?;'
     1364        self.assertTrue(re.search(r'^\$Version="?1"?;', cookie))
     1365        self.assertTrue(re.search(r'Part_Number="?Rocket_Launcher_0001"?;'
    13401366                               '\s*\$Path="\/acme"', cookie))
    1341         self.assert_(re.search(r'Customer="?WILE_E_COYOTE"?;\s*\$Path="\/acme"',
     1367        self.assertTrue(re.search(r'Customer="?WILE_E_COYOTE"?;\s*\$Path="\/acme"',
    13421368                               cookie))
    13431369
    … …  
    13611387
    13621388        cookie = interact_2965(c, "http://www.acme.com/acme/process")
    1363         self.assert_(
     1389        self.assertTrue(
    13641390            re.search(r'Shipping="?FedEx"?;\s*\$Path="\/acme"', cookie) and
    13651391            "WILE_E_COYOTE" in cookie)
    … …  
    14121438
    14131439        cookie = interact_2965(c, "http://www.acme.com/acme/ammo/...")
    1414         self.assert_(
     1440        self.assertTrue(
    14151441            re.search(r"Riding_Rocket_0023.*Rocket_Launcher_0001", cookie))
    14161442
    … …  
    14251451
    14261452        cookie = interact_2965(c, "http://www.acme.com/acme/parts/")
    1427         self.assert_("Rocket_Launcher_0001" in cookie and
    1428                      "Riding_Rocket_0023" not in cookie)
     1453        self.assertIn("Rocket_Launcher_0001", cookie)
     1454        self.assertNotIn("Riding_Rocket_0023", cookie)
    14291455
    14301456    def test_rejection(self):
    … …  
    14411467        cookie = interact_2965(c, "http://www.acme.com",
    14421468                               'foo=bar; domain=".com"; version=1')
    1443         self.assert_(not c)
     1469        self.assertTrue(not c)
    14441470
    14451471        # legal domain
    14461472        cookie = interact_2965(c, "http://www.acme.com",
    14471473                               'ping=pong; domain="acme.com"; version=1')
    1448         self.assertEquals(len(c), 1)
     1474        self.assertEqual(len(c), 1)
    14491475
    14501476        # illegal domain (host prefix "www.a" contains a dot)
    14511477        cookie = interact_2965(c, "http://www.a.acme.com",
    14521478                               'whiz=bang; domain="acme.com"; version=1')
    1453         self.assertEquals(len(c), 1)
     1479        self.assertEqual(len(c), 1)
    14541480
    14551481        # legal domain
    14561482        cookie = interact_2965(c, "http://www.a.acme.com",
    14571483                               'wow=flutter; domain=".a.acme.com"; version=1')
    1458         self.assertEquals(len(c), 2)
     1484        self.assertEqual(len(c), 2)
    14591485
    14601486        # can't partially match an IP-address
    14611487        cookie = interact_2965(c, "http://125.125.125.125",
    14621488                               'zzzz=ping; domain="125.125.125"; version=1')
    1463         self.assertEquals(len(c), 2)
     1489        self.assertEqual(len(c), 2)
    14641490
    14651491        # illegal path (must be prefix of request path)
    … …  
    14671493                               'blah=rhubarb; domain=".sol.no"; path="/foo"; '
    14681494                               'version=1')
    1469         self.assertEquals(len(c), 2)
     1495        self.assertEqual(len(c), 2)
    14701496
    14711497        # legal path
    … …  
    14731499                               'bing=bong; domain=".sol.no"; path="/foo"; '
    14741500                               'version=1')
    1475         self.assertEquals(len(c), 3)
     1501        self.assertEqual(len(c), 3)
    14761502
    14771503        # illegal port (request-port not in list)
    … …  
    14791505                               'whiz=ffft; domain=".sol.no"; port="90,100"; '
    14801506                               'version=1')
    1481         self.assertEquals(len(c), 3)
     1507        self.assertEqual(len(c), 3)
    14821508
    14831509        # legal port
    … …  
    14871513            r'port="90,100, 80,8080"; '
    14881514            r'max-age=100; Comment = "Just kidding! (\"|\\\\) "')
    1489         self.assertEquals(len(c), 4)
     1515        self.assertEqual(len(c), 4)
    14901516
    14911517        # port attribute without any value (current port)
    … …  
    14931519                               'foo9=bar; version=1; domain=".sol.no"; port; '
    14941520                               'max-age=100;')
    1495         self.assertEquals(len(c), 5)
     1521        self.assertEqual(len(c), 5)
    14961522
    14971523        # encoded path
    … …  
    15041530        cookie = interact_2965(c, "http://www.sol.no/<oo/",
    15051531                               r'foo8=bar; version=1; path="/%3coo"')
    1506         self.assertEquals(len(c), 6)
     1532        self.assertEqual(len(c), 6)
    15071533
    15081534        # save and restore
    … …  
    15191545            except OSError: pass
    15201546
    1521         self.assertEquals(old, repr(c))
     1547        self.assertEqual(old, repr(c))
    15221548
    15231549    def test_url_encoding(self):
    … …  
    15341560            'bar=baz; path="/foo/"; version=1');
    15351561        version_re = re.compile(r'^\$version=\"?1\"?', re.I)
    1536         self.assert_("foo=bar" in cookie and version_re.search(cookie))
     1562        self.assertTrue("foo=bar" in cookie and version_re.search(cookie))
    15371563
    15381564        cookie = interact_2965(
    15391565            c, "http://www.acme.com/foo/%25/<<%0anewå/æøå")
    1540         self.assert_(not cookie)
     1566        self.assertTrue(not cookie)
    15411567
    15421568        # unicode URL doesn't raise exception
    … …  
    15791605
    15801606        new_c = save_and_restore(c, True)
    1581         self.assertEquals(len(new_c), 6)  # none discarded
    1582         self.assert_("name='foo1', value='bar'" in repr(new_c))
     1607        self.assertEqual(len(new_c), 6)  # none discarded
     1608        self.assertIn("name='foo1', value='bar'", repr(new_c))
    15831609
    15841610        new_c = save_and_restore(c, False)
    1585         self.assertEquals(len(new_c), 4)  # 2 of them discarded on save
    1586         self.assert_("name='foo1', value='bar'" in repr(new_c))
     1611        self.assertEqual(len(new_c), 4)  # 2 of them discarded on save
     1612        self.assertIn("name='foo1', value='bar'", repr(new_c))
    15871613
    15881614    def test_netscape_misc(self):
    … …  
    16091635        req = Request("http://foo.bar.acme.com/foo")
    16101636        c.add_cookie_header(req)
    1611         self.assert_(
     1637        self.assertTrue(
    16121638            "PART_NUMBER=3,4" in req.get_header("Cookie") and
    16131639            "Customer=WILE_E_COYOTE" in req.get_header("Cookie"))
    … …  
    16221648        cookie = interact_2965(c, "http://example/",
    16231649                               'foo2=bar; domain=".local"; Version=1')
    1624         self.assert_("foo1=bar" in cookie)
     1650        self.assertIn("foo1=bar", cookie)
    16251651
    16261652        interact_2965(c, "http://example/", 'foo3=bar; Version=1')
    16271653        cookie = interact_2965(c, "http://example/")
    1628         self.assert_("foo2=bar" in cookie and len(c) == 3)
     1654        self.assertIn("foo2=bar", cookie)
     1655        self.assertEqual(len(c), 3)
    16291656
    16301657    def test_intranet_domains_ns(self):
    … …  
    16351662        cookie = interact_netscape(c, "http://example/",
    16361663                                   'foo2=bar; domain=.local')
    1637         self.assertEquals(len(c), 2)
    1638         self.assert_("foo1=bar" in cookie)
     1664        self.assertEqual(len(c), 2)
     1665        self.assertIn("foo1=bar", cookie)
    16391666
    16401667        cookie = interact_netscape(c, "http://example/")
    1641         self.assert_("foo2=bar" in cookie)
    1642         self.assertEquals(len(c), 2)
     1668        self.assertIn("foo2=bar", cookie)
     1669        self.assertEqual(len(c), 2)
    16431670
    16441671    def test_empty_path(self):
    … …  
    16641691        c.add_cookie_header(req)
    16651692
    1666         self.assertEquals(req.get_header("Cookie"),
    1667                           "JSESSIONID=ABCDERANDOM123")
    1668         self.assertEquals(req.get_header("Cookie2"), '$Version="1"')
     1693        self.assertEqual(req.get_header("Cookie"),
     1694                         "JSESSIONID=ABCDERANDOM123")
     1695        self.assertEqual(req.get_header("Cookie2"), '$Version="1"')
    16691696
    16701697        # missing path in the request URI
    … …  
    16721699        c.add_cookie_header(req)
    16731700
    1674         self.assertEquals(req.get_header("Cookie"),
    1675                           "JSESSIONID=ABCDERANDOM123")
    1676         self.assertEquals(req.get_header("Cookie2"), '$Version="1"')
     1701        self.assertEqual(req.get_header("Cookie"),
     1702                         "JSESSIONID=ABCDERANDOM123")
     1703        self.assertEqual(req.get_header("Cookie2"), '$Version="1"')
    16771704
    16781705    def test_session_cookies(self):
    … …  
    17141741            counter[key] = counter[key] + 1
    17151742
    1716         self.assert_(not (
     1743        self.assertTrue(not (
    17171744            # a permanent cookie got lost accidentally
    17181745            counter["perm_after"] != counter["perm_before"] or
    … …  
    17241751
    17251752def test_main(verbose=None):
    1726     from test import test_sets
    17271753    test_support.run_unittest(
    17281754        DateTimeTests,
Note: See TracChangeset for help on using the changeset viewer.