OLD | NEW |
1 """Regresssion tests for urllib""" | 1 """Regresssion tests for urllib""" |
2 | 2 |
3 import urllib.parse | 3 import urllib.parse |
4 import urllib.request | 4 import urllib.request |
5 import http.client | 5 import http.client |
6 import email.message | 6 import email.message |
7 import io | 7 import io |
8 import unittest | 8 import unittest |
9 from test import support | 9 from test import support |
10 import os | 10 import os |
(...skipping 318 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
329 """ | 329 """ |
330 | 330 |
331 def test_never_quote(self): | 331 def test_never_quote(self): |
332 # Make sure quote() does not quote letters, digits, and "_,.-" | 332 # Make sure quote() does not quote letters, digits, and "_,.-" |
333 do_not_quote = '' .join(["ABCDEFGHIJKLMNOPQRSTUVWXYZ", | 333 do_not_quote = '' .join(["ABCDEFGHIJKLMNOPQRSTUVWXYZ", |
334 "abcdefghijklmnopqrstuvwxyz", | 334 "abcdefghijklmnopqrstuvwxyz", |
335 "0123456789", | 335 "0123456789", |
336 "_.-"]) | 336 "_.-"]) |
337 result = urllib.parse.quote(do_not_quote) | 337 result = urllib.parse.quote(do_not_quote) |
338 self.assertEqual(do_not_quote, result, | 338 self.assertEqual(do_not_quote, result, |
339 "using quote(): %s != %s" % (do_not_quote, result)) | 339 "using quote(): %r != %r" % (do_not_quote, result)) |
340 result = urllib.parse.quote_plus(do_not_quote) | 340 result = urllib.parse.quote_plus(do_not_quote) |
341 self.assertEqual(do_not_quote, result, | 341 self.assertEqual(do_not_quote, result, |
342 "using quote_plus(): %s != %s" % (do_not_quote, result)) | 342 "using quote_plus(): %r != %r" % (do_not_quote, result)) |
343 | 343 |
344 def test_default_safe(self): | 344 def test_default_safe(self): |
345 # Test '/' is default value for 'safe' parameter | 345 # Test '/' is default value for 'safe' parameter |
346 self.assertEqual(urllib.parse.quote.__defaults__[0], '/') | 346 self.assertEqual(urllib.parse.quote.__defaults__[0], '/') |
347 | 347 |
348 def test_safe(self): | 348 def test_safe(self): |
349 # Test setting 'safe' parameter does what it should do | 349 # Test setting 'safe' parameter does what it should do |
350 quote_by_default = "<>" | 350 quote_by_default = "<>" |
351 result = urllib.parse.quote(quote_by_default, safe=quote_by_default) | 351 result = urllib.parse.quote(quote_by_default, safe=quote_by_default) |
352 self.assertEqual(quote_by_default, result, | 352 self.assertEqual(quote_by_default, result, |
353 "using quote(): %s != %s" % (quote_by_default, result)) | 353 "using quote(): %r != %r" % (quote_by_default, result)) |
354 result = urllib.parse.quote_plus(quote_by_default, safe=quote_by_default
) | 354 result = urllib.parse.quote_plus(quote_by_default, safe=quote_by_default
) |
355 self.assertEqual(quote_by_default, result, | 355 self.assertEqual(quote_by_default, result, |
356 "using quote_plus(): %s != %s" % | 356 "using quote_plus(): %r != %r" % |
357 (quote_by_default, result)) | 357 (quote_by_default, result)) |
| 358 # Safe expressed as bytes rather than str |
| 359 result = urllib.parse.quote(quote_by_default, safe=b"<>") |
| 360 self.assertEqual(quote_by_default, result, |
| 361 "using quote(): %r != %r" % (quote_by_default, result)) |
| 362 # "Safe" non-ASCII characters should have no effect |
| 363 # (Since URIs are not allowed to have non-ASCII characters) |
| 364 result = urllib.parse.quote("a\xfcb", encoding="latin-1", safe="\xfc") |
| 365 expect = urllib.parse.quote("a\xfcb", encoding="latin-1", safe="") |
| 366 self.assertEqual(expect, result, |
| 367 "using quote(): %r != %r" % |
| 368 (expect, result)) |
| 369 # Same as above, but using a bytes rather than str |
| 370 result = urllib.parse.quote("a\xfcb", encoding="latin-1", safe=b"\xfc") |
| 371 expect = urllib.parse.quote("a\xfcb", encoding="latin-1", safe="") |
| 372 self.assertEqual(expect, result, |
| 373 "using quote(): %r != %r" % |
| 374 (expect, result)) |
358 | 375 |
359 def test_default_quoting(self): | 376 def test_default_quoting(self): |
360 # Make sure all characters that should be quoted are by default sans | 377 # Make sure all characters that should be quoted are by default sans |
361 # space (separate test for that). | 378 # space (separate test for that). |
362 should_quote = [chr(num) for num in range(32)] # For 0x00 - 0x1F | 379 should_quote = [chr(num) for num in range(32)] # For 0x00 - 0x1F |
363 should_quote.append('<>#%"{}|\^[]`') | 380 should_quote.append('<>#%"{}|\^[]`') |
364 should_quote.append(chr(127)) # For 0x7F | 381 should_quote.append(chr(127)) # For 0x7F |
365 should_quote = ''.join(should_quote) | 382 should_quote = ''.join(should_quote) |
366 for char in should_quote: | 383 for char in should_quote: |
367 result = urllib.parse.quote(char) | 384 result = urllib.parse.quote(char) |
368 self.assertEqual(hexescape(char), result, | 385 self.assertEqual(hexescape(char), result, |
369 "using quote(): %s should be escaped to %s, not %s"
% | 386 "using quote(): %s should be escaped to %s, not %s"
% |
370 (char, hexescape(char), result)) | 387 (char, hexescape(char), result)) |
371 result = urllib.parse.quote_plus(char) | 388 result = urllib.parse.quote_plus(char) |
372 self.assertEqual(hexescape(char), result, | 389 self.assertEqual(hexescape(char), result, |
373 "using quote_plus(): " | 390 "using quote_plus(): " |
374 "%s should be escapes to %s, not %s" % | 391 "%s should be escapes to %s, not %s" % |
375 (char, hexescape(char), result)) | 392 (char, hexescape(char), result)) |
376 del should_quote | 393 del should_quote |
377 partial_quote = "ab[]cd" | 394 partial_quote = "ab[]cd" |
378 expected = "ab%5B%5Dcd" | 395 expected = "ab%5B%5Dcd" |
379 result = urllib.parse.quote(partial_quote) | 396 result = urllib.parse.quote(partial_quote) |
380 self.assertEqual(expected, result, | 397 self.assertEqual(expected, result, |
381 "using quote(): %s != %s" % (expected, result)) | 398 "using quote(): %r != %r" % (expected, result)) |
382 self.assertEqual(expected, result, | 399 self.assertEqual(expected, result, |
383 "using quote_plus(): %s != %s" % (expected, result)) | 400 "using quote_plus(): %r != %r" % (expected, result)) |
384 | 401 |
385 def test_quoting_space(self): | 402 def test_quoting_space(self): |
386 # Make sure quote() and quote_plus() handle spaces as specified in | 403 # Make sure quote() and quote_plus() handle spaces as specified in |
387 # their unique way | 404 # their unique way |
388 result = urllib.parse.quote(' ') | 405 result = urllib.parse.quote(' ') |
389 self.assertEqual(result, hexescape(' '), | 406 self.assertEqual(result, hexescape(' '), |
390 "using quote(): %s != %s" % (result, hexescape(' '))) | 407 "using quote(): %r != %r" % (result, hexescape(' '))) |
391 result = urllib.parse.quote_plus(' ') | 408 result = urllib.parse.quote_plus(' ') |
392 self.assertEqual(result, '+', | 409 self.assertEqual(result, '+', |
393 "using quote_plus(): %s != +" % result) | 410 "using quote_plus(): %r != +" % result) |
394 given = "a b cd e f" | 411 given = "a b cd e f" |
395 expect = given.replace(' ', hexescape(' ')) | 412 expect = given.replace(' ', hexescape(' ')) |
396 result = urllib.parse.quote(given) | 413 result = urllib.parse.quote(given) |
397 self.assertEqual(expect, result, | 414 self.assertEqual(expect, result, |
398 "using quote(): %s != %s" % (expect, result)) | 415 "using quote(): %r != %r" % (expect, result)) |
399 expect = given.replace(' ', '+') | 416 expect = given.replace(' ', '+') |
400 result = urllib.parse.quote_plus(given) | 417 result = urllib.parse.quote_plus(given) |
401 self.assertEqual(expect, result, | 418 self.assertEqual(expect, result, |
402 "using quote_plus(): %s != %s" % (expect, result)) | 419 "using quote_plus(): %r != %r" % (expect, result)) |
403 | 420 |
404 def test_quoting_plus(self): | 421 def test_quoting_plus(self): |
405 self.assertEqual(urllib.parse.quote_plus('alpha+beta gamma'), | 422 self.assertEqual(urllib.parse.quote_plus('alpha+beta gamma'), |
406 'alpha%2Bbeta+gamma') | 423 'alpha%2Bbeta+gamma') |
407 self.assertEqual(urllib.parse.quote_plus('alpha+beta gamma', '+'), | 424 self.assertEqual(urllib.parse.quote_plus('alpha+beta gamma', '+'), |
408 'alpha+beta+gamma') | 425 'alpha+beta+gamma') |
| 426 # Test with bytes |
| 427 self.assertEqual(urllib.parse.quote_plus(b'alpha+beta gamma'), |
| 428 'alpha%2Bbeta+gamma') |
| 429 # Test with safe bytes |
| 430 self.assertEqual(urllib.parse.quote_plus('alpha+beta gamma', b'+'), |
| 431 'alpha+beta+gamma') |
| 432 |
| 433 def test_quote_bytes(self): |
| 434 # Bytes should quote directly to percent-encoded values |
| 435 given = b"\xa2\xd8ab\xff" |
| 436 expect = "%A2%D8ab%FF" |
| 437 result = urllib.parse.quote(given) |
| 438 self.assertEqual(expect, result, |
| 439 "using quote(): %r != %r" % (expect, result)) |
| 440 # Encoding argument should raise type error on bytes input |
| 441 self.assertRaises(TypeError, urllib.parse.quote, given, |
| 442 encoding="latin-1") |
| 443 # quote_from_bytes should work the same |
| 444 result = urllib.parse.quote_from_bytes(given) |
| 445 self.assertEqual(expect, result, |
| 446 "using quote_from_bytes(): %r != %r" |
| 447 % (expect, result)) |
| 448 |
| 449 def test_quote_with_unicode(self): |
| 450 # Characters in Latin-1 range, encoded by default in UTF-8 |
| 451 given = "\xa2\xd8ab\xff" |
| 452 expect = "%C2%A2%C3%98ab%C3%BF" |
| 453 result = urllib.parse.quote(given) |
| 454 self.assertEqual(expect, result, |
| 455 "using quote(): %r != %r" % (expect, result)) |
| 456 # Characters in Latin-1 range, encoded by with None (default) |
| 457 result = urllib.parse.quote(given, encoding=None, errors=None) |
| 458 self.assertEqual(expect, result, |
| 459 "using quote(): %r != %r" % (expect, result)) |
| 460 # Characters in Latin-1 range, encoded with Latin-1 |
| 461 given = "\xa2\xd8ab\xff" |
| 462 expect = "%A2%D8ab%FF" |
| 463 result = urllib.parse.quote(given, encoding="latin-1") |
| 464 self.assertEqual(expect, result, |
| 465 "using quote(): %r != %r" % (expect, result)) |
| 466 # Characters in BMP, encoded by default in UTF-8 |
| 467 given = "\u6f22\u5b57" # "Kanji" |
| 468 expect = "%E6%BC%A2%E5%AD%97" |
| 469 result = urllib.parse.quote(given) |
| 470 self.assertEqual(expect, result, |
| 471 "using quote(): %r != %r" % (expect, result)) |
| 472 # Characters in BMP, encoded with Latin-1 |
| 473 given = "\u6f22\u5b57" |
| 474 self.assertRaises(UnicodeEncodeError, urllib.parse.quote, given, |
| 475 encoding="latin-1") |
| 476 # Characters in BMP, encoded with Latin-1, with replace error handling |
| 477 given = "\u6f22\u5b57" |
| 478 expect = "%3F%3F" # "??" |
| 479 result = urllib.parse.quote(given, encoding="latin-1", |
| 480 errors="replace") |
| 481 self.assertEqual(expect, result, |
| 482 "using quote(): %r != %r" % (expect, result)) |
| 483 # Characters in BMP, Latin-1, with xmlcharref error handling |
| 484 given = "\u6f22\u5b57" |
| 485 expect = "%26%2328450%3B%26%2323383%3B" # "漢字" |
| 486 result = urllib.parse.quote(given, encoding="latin-1", |
| 487 errors="xmlcharrefreplace") |
| 488 self.assertEqual(expect, result, |
| 489 "using quote(): %r != %r" % (expect, result)) |
409 | 490 |
410 class UnquotingTests(unittest.TestCase): | 491 class UnquotingTests(unittest.TestCase): |
411 """Tests for unquote() and unquote_plus() | 492 """Tests for unquote() and unquote_plus() |
412 | 493 |
413 See the doc string for quoting_Tests for details on quoting and such. | 494 See the doc string for quoting_Tests for details on quoting and such. |
414 | 495 |
415 """ | 496 """ |
416 | 497 |
417 def test_unquoting(self): | 498 def test_unquoting(self): |
418 # Make sure unquoting of all ASCII values works | 499 # Make sure unquoting of all ASCII values works |
419 escape_list = [] | 500 escape_list = [] |
420 for num in range(128): | 501 for num in range(128): |
421 given = hexescape(chr(num)) | 502 given = hexescape(chr(num)) |
422 expect = chr(num) | 503 expect = chr(num) |
423 result = urllib.parse.unquote(given) | 504 result = urllib.parse.unquote(given) |
424 self.assertEqual(expect, result, | 505 self.assertEqual(expect, result, |
425 "using unquote(): %s != %s" % (expect, result)) | 506 "using unquote(): %r != %r" % (expect, result)) |
426 result = urllib.parse.unquote_plus(given) | 507 result = urllib.parse.unquote_plus(given) |
427 self.assertEqual(expect, result, | 508 self.assertEqual(expect, result, |
428 "using unquote_plus(): %s != %s" % | 509 "using unquote_plus(): %r != %r" % |
429 (expect, result)) | 510 (expect, result)) |
430 escape_list.append(given) | 511 escape_list.append(given) |
431 escape_string = ''.join(escape_list) | 512 escape_string = ''.join(escape_list) |
432 del escape_list | 513 del escape_list |
433 result = urllib.parse.unquote(escape_string) | 514 result = urllib.parse.unquote(escape_string) |
434 self.assertEqual(result.count('%'), 1, | 515 self.assertEqual(result.count('%'), 1, |
435 "using quote(): not all characters escaped; %s" % | |
436 result) | |
437 result = urllib.parse.unquote(escape_string) | |
438 self.assertEqual(result.count('%'), 1, | |
439 "using unquote(): not all characters escaped: " | 516 "using unquote(): not all characters escaped: " |
440 "%s" % result) | 517 "%s" % result) |
441 | 518 |
| 519 def test_unquoting_badpercent(self): |
| 520 # Test unquoting on bad percent-escapes |
| 521 given = '%xab' |
| 522 expect = given |
| 523 result = urllib.parse.unquote(given) |
| 524 self.assertEqual(expect, result, "using unquote(): %r != %r" |
| 525 % (expect, result)) |
| 526 given = '%x' |
| 527 expect = given |
| 528 result = urllib.parse.unquote(given) |
| 529 self.assertEqual(expect, result, "using unquote(): %r != %r" |
| 530 % (expect, result)) |
| 531 given = '%' |
| 532 expect = given |
| 533 result = urllib.parse.unquote(given) |
| 534 self.assertEqual(expect, result, "using unquote(): %r != %r" |
| 535 % (expect, result)) |
| 536 # unquote_to_bytes |
| 537 given = '%xab' |
| 538 expect = bytes(given, 'ascii') |
| 539 result = urllib.parse.unquote_to_bytes(given) |
| 540 self.assertEqual(expect, result, "using unquote_to_bytes(): %r != %r" |
| 541 % (expect, result)) |
| 542 given = '%x' |
| 543 expect = bytes(given, 'ascii') |
| 544 result = urllib.parse.unquote_to_bytes(given) |
| 545 self.assertEqual(expect, result, "using unquote_to_bytes(): %r != %r" |
| 546 % (expect, result)) |
| 547 given = '%' |
| 548 expect = bytes(given, 'ascii') |
| 549 result = urllib.parse.unquote_to_bytes(given) |
| 550 self.assertEqual(expect, result, "using unquote_to_bytes(): %r != %r" |
| 551 % (expect, result)) |
| 552 |
| 553 def test_unquoting_mixed_case(self): |
| 554 # Test unquoting on mixed-case hex digits in the percent-escapes |
| 555 given = '%Ab%eA' |
| 556 expect = b'\xab\xea' |
| 557 result = urllib.parse.unquote_to_bytes(given) |
| 558 self.assertEqual(expect, result, |
| 559 "using unquote_to_bytes(): %r != %r" |
| 560 % (expect, result)) |
| 561 |
442 def test_unquoting_parts(self): | 562 def test_unquoting_parts(self): |
443 # Make sure unquoting works when have non-quoted characters | 563 # Make sure unquoting works when have non-quoted characters |
444 # interspersed | 564 # interspersed |
445 given = 'ab%sd' % hexescape('c') | 565 given = 'ab%sd' % hexescape('c') |
446 expect = "abcd" | 566 expect = "abcd" |
447 result = urllib.parse.unquote(given) | 567 result = urllib.parse.unquote(given) |
448 self.assertEqual(expect, result, | 568 self.assertEqual(expect, result, |
449 "using quote(): %s != %s" % (expect, result)) | 569 "using quote(): %r != %r" % (expect, result)) |
450 result = urllib.parse.unquote_plus(given) | 570 result = urllib.parse.unquote_plus(given) |
451 self.assertEqual(expect, result, | 571 self.assertEqual(expect, result, |
452 "using unquote_plus(): %s != %s" % (expect, result)) | 572 "using unquote_plus(): %r != %r" % (expect, result)) |
453 | 573 |
454 def test_unquoting_plus(self): | 574 def test_unquoting_plus(self): |
455 # Test difference between unquote() and unquote_plus() | 575 # Test difference between unquote() and unquote_plus() |
456 given = "are+there+spaces..." | 576 given = "are+there+spaces..." |
457 expect = given | 577 expect = given |
458 result = urllib.parse.unquote(given) | 578 result = urllib.parse.unquote(given) |
459 self.assertEqual(expect, result, | 579 self.assertEqual(expect, result, |
460 "using unquote(): %s != %s" % (expect, result)) | 580 "using unquote(): %r != %r" % (expect, result)) |
461 expect = given.replace('+', ' ') | 581 expect = given.replace('+', ' ') |
462 result = urllib.parse.unquote_plus(given) | 582 result = urllib.parse.unquote_plus(given) |
463 self.assertEqual(expect, result, | 583 self.assertEqual(expect, result, |
464 "using unquote_plus(): %s != %s" % (expect, result)) | 584 "using unquote_plus(): %r != %r" % (expect, result)) |
| 585 |
| 586 def test_unquote_to_bytes(self): |
| 587 given = 'br%C3%BCckner_sapporo_20050930.doc' |
| 588 expect = b'br\xc3\xbcckner_sapporo_20050930.doc' |
| 589 result = urllib.parse.unquote_to_bytes(given) |
| 590 self.assertEqual(expect, result, |
| 591 "using unquote_to_bytes(): %r != %r" |
| 592 % (expect, result)) |
| 593 # Test on a string with unescaped non-ASCII characters |
| 594 # (Technically an invalid URI; expect those characters to be UTF-8 |
| 595 # encoded). |
| 596 result = urllib.parse.unquote_to_bytes("\u6f22%C3%BC") |
| 597 expect = b'\xe6\xbc\xa2\xc3\xbc' # UTF-8 for "\u6f22\u00fc" |
| 598 self.assertEqual(expect, result, |
| 599 "using unquote_to_bytes(): %r != %r" |
| 600 % (expect, result)) |
| 601 # Test with a bytes as input |
| 602 given = b'%A2%D8ab%FF' |
| 603 expect = b'\xa2\xd8ab\xff' |
| 604 result = urllib.parse.unquote_to_bytes(given) |
| 605 self.assertEqual(expect, result, |
| 606 "using unquote_to_bytes(): %r != %r" |
| 607 % (expect, result)) |
| 608 # Test with a bytes as input, with unescaped non-ASCII bytes |
| 609 # (Technically an invalid URI; expect those bytes to be preserved) |
| 610 given = b'%A2\xd8ab%FF' |
| 611 expect = b'\xa2\xd8ab\xff' |
| 612 result = urllib.parse.unquote_to_bytes(given) |
| 613 self.assertEqual(expect, result, |
| 614 "using unquote_to_bytes(): %r != %r" |
| 615 % (expect, result)) |
465 | 616 |
466 def test_unquote_with_unicode(self): | 617 def test_unquote_with_unicode(self): |
467 r = urllib.parse.unquote('br%C3%BCckner_sapporo_20050930.doc') | 618 # Characters in the Latin-1 range, encoded with UTF-8 |
468 self.assertEqual(r, 'br\xc3\xbcckner_sapporo_20050930.doc') | 619 given = 'br%C3%BCckner_sapporo_20050930.doc' |
| 620 expect = 'br\u00fcckner_sapporo_20050930.doc' |
| 621 result = urllib.parse.unquote(given) |
| 622 self.assertEqual(expect, result, |
| 623 "using unquote(): %r != %r" % (expect, result)) |
| 624 # Characters in the Latin-1 range, encoded with None (default) |
| 625 result = urllib.parse.unquote(given, encoding=None, errors=None) |
| 626 self.assertEqual(expect, result, |
| 627 "using unquote(): %r != %r" % (expect, result)) |
| 628 |
| 629 # Characters in the Latin-1 range, encoded with Latin-1 |
| 630 result = urllib.parse.unquote('br%FCckner_sapporo_20050930.doc', |
| 631 encoding="latin-1") |
| 632 expect = 'br\u00fcckner_sapporo_20050930.doc' |
| 633 self.assertEqual(expect, result, |
| 634 "using unquote(): %r != %r" % (expect, result)) |
| 635 |
| 636 # Characters in BMP, encoded with UTF-8 |
| 637 given = "%E6%BC%A2%E5%AD%97" |
| 638 expect = "\u6f22\u5b57" # "Kanji" |
| 639 result = urllib.parse.unquote(given) |
| 640 self.assertEqual(expect, result, |
| 641 "using unquote(): %r != %r" % (expect, result)) |
| 642 |
| 643 # Decode with UTF-8, invalid sequence |
| 644 given = "%F3%B1" |
| 645 expect = "\ufffd" # Replacement character |
| 646 result = urllib.parse.unquote(given) |
| 647 self.assertEqual(expect, result, |
| 648 "using unquote(): %r != %r" % (expect, result)) |
| 649 |
| 650 # Decode with UTF-8, invalid sequence, replace errors |
| 651 result = urllib.parse.unquote(given, errors="replace") |
| 652 self.assertEqual(expect, result, |
| 653 "using unquote(): %r != %r" % (expect, result)) |
| 654 |
| 655 # Decode with UTF-8, invalid sequence, ignoring errors |
| 656 given = "%F3%B1" |
| 657 expect = "" |
| 658 result = urllib.parse.unquote(given, errors="ignore") |
| 659 self.assertEqual(expect, result, |
| 660 "using unquote(): %r != %r" % (expect, result)) |
| 661 |
| 662 # A mix of non-ASCII and percent-encoded characters, UTF-8 |
| 663 result = urllib.parse.unquote("\u6f22%C3%BC") |
| 664 expect = '\u6f22\u00fc' |
| 665 self.assertEqual(expect, result, |
| 666 "using unquote(): %r != %r" % (expect, result)) |
| 667 |
| 668 # A mix of non-ASCII and percent-encoded characters, Latin-1 |
| 669 # (Note, the string contains non-Latin-1-representable characters) |
| 670 result = urllib.parse.unquote("\u6f22%FC", encoding="latin-1") |
| 671 expect = '\u6f22\u00fc' |
| 672 self.assertEqual(expect, result, |
| 673 "using unquote(): %r != %r" % (expect, result)) |
469 | 674 |
470 class urlencode_Tests(unittest.TestCase): | 675 class urlencode_Tests(unittest.TestCase): |
471 """Tests for urlencode()""" | 676 """Tests for urlencode()""" |
472 | 677 |
473 def help_inputtype(self, given, test_type): | 678 def help_inputtype(self, given, test_type): |
474 """Helper method for testing different input types. | 679 """Helper method for testing different input types. |
475 | 680 |
476 'given' must lead to only the pairs: | 681 'given' must lead to only the pairs: |
477 * 1st, 1 | 682 * 1st, 1 |
478 * 2nd, 2 | 683 * 2nd, 2 |
(...skipping 190 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
669 UnquotingTests, | 874 UnquotingTests, |
670 urlencode_Tests, | 875 urlencode_Tests, |
671 Pathname_Tests, | 876 Pathname_Tests, |
672 #FTPWrapperTests, | 877 #FTPWrapperTests, |
673 ) | 878 ) |
674 | 879 |
675 | 880 |
676 | 881 |
677 if __name__ == '__main__': | 882 if __name__ == '__main__': |
678 test_main() | 883 test_main() |
OLD | NEW |