← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2009-01-13 05:14:24 UTC
  • mfrom: (3936.1.3 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20090113051424-nrk3zkfe09h46i9y
(mbp) merge 1.11 and advance to 1.12

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
"""Tests for the urlutils wrapper."""
18
18
 
19
19
import os
 
20
import re
20
21
import sys
21
22
 
22
23
from bzrlib import osutils, urlutils, win32utils
25
26
 
26
27
 
27
28
class TestUrlToPath(TestCase):
28
 
 
 
29
    
29
30
    def test_basename(self):
30
31
        # bzrlib.urlutils.basename
31
32
        # Test bzrlib.urlutils.split()
82
83
        try:
83
84
            u'uni/\xb5'.encode(osutils.get_user_encoding())
84
85
        except UnicodeError:
85
 
            # locale cannot handle unicode
 
86
            # locale cannot handle unicode 
86
87
            pass
87
88
        else:
88
89
            norm_file('uni/%C2%B5', u'uni/\xb5')
156
157
        # Weird stuff
157
158
        # Can't have slashes or colons in the scheme
158
159
        test_one('/path/to/://foo', None)
159
 
        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
 
160
        test_one('path:path://foo', None)
160
161
        # Must have more than one character for scheme
161
162
        test_one('C://foo', None)
162
163
        test_one('ab://foo', ('ab', 'foo'))
195
196
            dirname('path/to/foo/', exclude_trailing_slash=False))
196
197
        self.assertEqual('path/..', dirname('path/../foo'))
197
198
        self.assertEqual('../path', dirname('../path/foo'))
198
 
    
199
 
    def test_is_url(self):
200
 
        self.assertTrue(urlutils.is_url('http://foo/bar'))
201
 
        self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))
202
 
        self.assertTrue(urlutils.is_url('lp:foo/bar'))
203
 
        self.assertTrue(urlutils.is_url('file:///foo/bar'))
204
 
        self.assertFalse(urlutils.is_url(''))
205
 
        self.assertFalse(urlutils.is_url('foo'))
206
 
        self.assertFalse(urlutils.is_url('foo/bar'))
207
 
        self.assertFalse(urlutils.is_url('/foo'))
208
 
        self.assertFalse(urlutils.is_url('/foo/bar'))
209
 
        self.assertFalse(urlutils.is_url('C:/'))
210
 
        self.assertFalse(urlutils.is_url('C:/foo'))
211
 
        self.assertFalse(urlutils.is_url('C:/foo/bar'))
212
199
 
213
200
    def test_join(self):
214
201
        def test(expected, *args):
224
211
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
225
212
        test('http://foo/baz', 'http://foo', 'bar/../baz')
226
213
        test('http://foo/baz', 'http://foo/bar/', '../baz')
227
 
        test('lp:foo/bar', 'lp:foo', 'bar')
228
 
        test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')
229
214
 
230
215
        # Absolute paths
231
216
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
235
220
        test('http://bar/', 'http://foo', 'http://bar/')
236
221
        test('http://bar/a', 'http://foo', 'http://bar/a')
237
222
        test('http://bar/a/', 'http://foo', 'http://bar/a/')
238
 
        test('lp:bar', 'http://foo', 'lp:bar')
239
 
        test('lp:bar', 'lp:foo', 'lp:bar')
240
 
        test('file:///stuff', 'lp:foo', 'file:///stuff')
241
223
 
242
224
        # From a base path
243
225
        test('file:///foo', 'file:///', 'foo')
244
226
        test('file:///bar/foo', 'file:///bar/', 'foo')
245
227
        test('http://host/foo', 'http://host/', 'foo')
246
228
        test('http://host/', 'http://host', '')
247
 
 
 
229
        
248
230
        # Invalid joinings
249
231
        # Cannot go above root
250
232
        # Implicitly at root:
282
264
 
283
265
        # Test joining to a path with a trailing slash
284
266
        test('foo/bar', 'foo/', 'bar')
285
 
 
 
267
        
286
268
        # Invalid joinings
287
269
        # Cannot go above root
288
270
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '../baz')
289
271
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
290
272
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
291
273
 
292
 
    def test_join_segment_parameters_raw(self):
293
 
        join_segment_parameters_raw = urlutils.join_segment_parameters_raw
294
 
        self.assertEquals("/somedir/path", 
295
 
            join_segment_parameters_raw("/somedir/path"))
296
 
        self.assertEquals("/somedir/path,rawdata", 
297
 
            join_segment_parameters_raw("/somedir/path", "rawdata"))
298
 
        self.assertRaises(InvalidURLJoin,
299
 
            join_segment_parameters_raw, "/somedir/path",
300
 
                "rawdata1,rawdata2,rawdata3")
301
 
        self.assertEquals("/somedir/path,bla,bar",
302
 
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
303
 
        self.assertEquals("/somedir,exist=some/path,bla,bar",
304
 
            join_segment_parameters_raw("/somedir,exist=some/path",
305
 
                "bla", "bar"))
306
 
        self.assertRaises(TypeError, join_segment_parameters_raw, 
307
 
            "/somepath", 42)
308
 
 
309
 
    def test_join_segment_parameters(self):
310
 
        join_segment_parameters = urlutils.join_segment_parameters
311
 
        self.assertEquals("/somedir/path", 
312
 
            join_segment_parameters("/somedir/path", {}))
313
 
        self.assertEquals("/somedir/path,key1=val1", 
314
 
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
315
 
        self.assertRaises(InvalidURLJoin,
316
 
            join_segment_parameters, "/somedir/path",
317
 
            {"branch": "brr,brr,brr"})
318
 
        self.assertRaises(InvalidURLJoin,
319
 
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
320
 
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
321
 
            join_segment_parameters("/somedir/path", {
322
 
                "key1": "val1", "key2": "val2"}))
323
 
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
324
 
            join_segment_parameters("/somedir/path,key1=val1", {
325
 
                "key2": "val2"}))
326
 
        self.assertEquals("/somedir/path,key1=val2",
327
 
            join_segment_parameters("/somedir/path,key1=val1", {
328
 
                "key1": "val2"}))
329
 
        self.assertEquals("/somedir,exist=some/path,key1=val1",
330
 
            join_segment_parameters("/somedir,exist=some/path",
331
 
                {"key1": "val1"}))
332
 
        self.assertEquals("/,key1=val1,key2=val2",
333
 
            join_segment_parameters("/,key1=val1", {"key2": "val2"}))
334
 
        self.assertRaises(TypeError,
335
 
            join_segment_parameters, "/,key1=val1", {"foo": 42})
336
 
 
337
274
    def test_function_type(self):
338
275
        if sys.platform == 'win32':
339
 
            self.assertEqual(urlutils._win32_local_path_to_url,
340
 
                urlutils.local_path_to_url)
341
 
            self.assertEqual(urlutils._win32_local_path_from_url,
342
 
                urlutils.local_path_from_url)
 
276
            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
 
277
            self.assertEqual(urlutils._win32_local_path_from_url, urlutils.local_path_from_url)
343
278
        else:
344
 
            self.assertEqual(urlutils._posix_local_path_to_url,
345
 
                urlutils.local_path_to_url)
346
 
            self.assertEqual(urlutils._posix_local_path_from_url,
347
 
                urlutils.local_path_from_url)
 
279
            self.assertEqual(urlutils._posix_local_path_to_url, urlutils.local_path_to_url)
 
280
            self.assertEqual(urlutils._posix_local_path_from_url, urlutils.local_path_from_url)
348
281
 
349
282
    def test_posix_local_path_to_url(self):
350
283
        to_url = urlutils._posix_local_path_to_url
351
284
        self.assertEqual('file:///path/to/foo',
352
285
            to_url('/path/to/foo'))
353
286
 
354
 
        self.assertEqual('file:///path/to/foo%2Cbar',
355
 
            to_url('/path/to/foo,bar'))
356
 
 
357
287
        try:
358
288
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
359
289
        except UnicodeError:
366
296
        from_url = urlutils._posix_local_path_from_url
367
297
        self.assertEqual('/path/to/foo',
368
298
            from_url('file:///path/to/foo'))
369
 
        self.assertEqual('/path/to/foo',
370
 
            from_url('file:///path/to/foo,branch=foo'))
371
299
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
372
300
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
373
301
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
374
302
            from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
375
 
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
376
 
            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
377
303
 
378
304
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
379
 
        self.assertRaises(
380
 
            InvalidURL, from_url,
381
 
            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')
382
305
 
383
306
    def test_win32_local_path_to_url(self):
384
307
        to_url = urlutils._win32_local_path_to_url
392
315
        #     to_url('C:/path/to/foo '))
393
316
        self.assertEqual('file:///C:/path/to/f%20oo',
394
317
            to_url('C:/path/to/f oo'))
395
 
 
 
318
        
396
319
        self.assertEqual('file:///', to_url('/'))
397
320
 
398
 
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
399
 
            to_url('C:/path/to/foo,bar'))
400
321
        try:
401
322
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
402
323
        except UnicodeError:
429
350
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
430
351
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
431
352
        self.assertEqual('/', from_url('file:///'))
432
 
        self.assertEqual('C:/path/to/foo',
433
 
            from_url('file:///C|/path/to/foo,branch=foo'))
434
353
 
435
 
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
436
 
        self.assertRaises(InvalidURL, from_url, 'file:///c')
437
354
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
438
355
        # Not a valid _win32 url, no drive letter
439
356
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
441
358
    def test_win32_unc_path_from_url(self):
442
359
        from_url = urlutils._win32_local_path_from_url
443
360
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
444
 
        self.assertEqual('//HOST/path',
445
 
            from_url('file://HOST/path,branch=foo'))
446
361
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
447
362
        # we want to use only 2 slashes
448
363
        # Firefox understand only 5 slashes in URL, but it's ugly
457
372
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
458
373
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
459
374
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
460
 
        # Root drives without slash treated as invalid, see bug #841322
461
 
        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
462
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C:')
463
 
        # Invalid without drive separator or following forward slash
464
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C')
465
 
        self.assertRaises(InvalidURL, extract, 'file://', '/C:ool')
466
375
 
467
376
    def test_split(self):
468
377
        # Test bzrlib.urlutils.split()
499
408
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
500
409
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
501
410
 
502
 
    def test_split_segment_parameters_raw(self):
503
 
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
504
 
        self.assertEquals(("/some/path", []),
505
 
            split_segment_parameters_raw("/some/path"))
506
 
        self.assertEquals(("/some/path", ["tip"]),
507
 
            split_segment_parameters_raw("/some/path,tip"))
508
 
        self.assertEquals(("/some,dir/path", ["tip"]),
509
 
            split_segment_parameters_raw("/some,dir/path,tip"))
510
 
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
511
 
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
512
 
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
513
 
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
514
 
        self.assertEquals(("/", ["key1=val1"]),
515
 
            split_segment_parameters_raw(",key1=val1"))
516
 
        self.assertEquals(("foo/", ["key1=val1"]),
517
 
            split_segment_parameters_raw("foo/,key1=val1"))
518
 
        self.assertEquals(("/foo", ["key1=val1"]),
519
 
            split_segment_parameters_raw("foo,key1=val1"))
520
 
        self.assertEquals(("foo/base,la=bla/other/elements", []),
521
 
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
522
 
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
523
 
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
524
 
 
525
 
    def test_split_segment_parameters(self):
526
 
        split_segment_parameters = urlutils.split_segment_parameters
527
 
        self.assertEquals(("/some/path", {}),
528
 
            split_segment_parameters("/some/path"))
529
 
        self.assertEquals(("/some/path", {"branch": "tip"}),
530
 
            split_segment_parameters("/some/path,branch=tip"))
531
 
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
532
 
            split_segment_parameters("/some,dir/path,branch=tip"))
533
 
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
534
 
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
535
 
        self.assertEquals(("/somedir/path",
536
 
            {"ref": "heads%2Ftip", "key1": "val1"}),
537
 
            split_segment_parameters(
538
 
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
539
 
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
540
 
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
541
 
        self.assertEquals(("/", {"key1": "val1"}),
542
 
            split_segment_parameters(",key1=val1"))
543
 
        self.assertEquals(("foo/", {"key1": "val1"}),
544
 
            split_segment_parameters("foo/,key1=val1"))
545
 
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
546
 
            split_segment_parameters("foo/base,key1=val1/other/elements"))
547
 
        self.assertEquals(("foo/base,key1=val1/other/elements",
548
 
            {"key2": "val2"}), split_segment_parameters(
549
 
                "foo/base,key1=val1/other/elements,key2=val2"))
550
 
 
551
411
    def test_win32_strip_local_trailing_slash(self):
552
412
        strip = urlutils._win32_strip_local_trailing_slash
553
413
        self.assertEqual('file://', strip('file://'))
637
497
        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
638
498
        self.assertFalse(isinstance(urlutils.escape(u'\xe5'), unicode))
639
499
 
640
 
    def test_escape_tildes(self):
641
 
        self.assertEqual('~foo', urlutils.escape('~foo'))
642
 
 
643
500
    def test_unescape(self):
644
501
        self.assertEqual('%', urlutils.unescape('%25'))
645
502
        self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
656
513
        def test(expected, base, other):
657
514
            result = urlutils.relative_url(base, other)
658
515
            self.assertEqual(expected, result)
659
 
 
 
516
            
660
517
        test('a', 'http://host/', 'http://host/a')
661
518
        test('http://entirely/different', 'sftp://host/branch',
662
519
                    'http://entirely/different')
671
528
                    'sftp://host/home/jelmer/branch/2b')
672
529
        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
673
530
                    'http://host/home/jelmer/branch/feature/%2b')
674
 
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/',
 
531
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/', 
675
532
                    'http://host/home/jelmer/branch/feature/2b')
676
533
        # relative_url should preserve a trailing slash
677
534
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
735
592
 
736
593
        os.chdir(u'dod\xe9')
737
594
 
738
 
        # On Mac OSX this directory is actually:
 
595
        # On Mac OSX this directory is actually: 
739
596
        #   u'/dode\u0301' => '/dode\xcc\x81
740
 
        # but we should normalize it back to
 
597
        # but we should normalize it back to 
741
598
        #   u'/dod\xe9' => '/dod\xc3\xa9'
742
599
        url = urlutils.local_path_to_url('.')
743
600
        self.assertEndsWith(url, '/dod%C3%A9')
812
669
                         '/bar', '/bar/baz'))
813
670
        self.assertEqual('.', urlutils.determine_relative_path(
814
671
                         '/bar', '/bar'))
815
 
 
816
 
 
817
 
class TestParseURL(TestCase):
818
 
 
819
 
    def test_parse_simple(self):
820
 
        parsed = urlutils.parse_url('http://example.com:80/one')
821
 
        self.assertEquals(('http', None, None, 'example.com', 80, '/one'),
822
 
            parsed)
823
 
 
824
 
    def test_ipv6(self):
825
 
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
826
 
        self.assertEquals(('http', None, None, '1:2:3::40', None, '/one'),
827
 
            parsed)
828
 
 
829
 
    def test_ipv6_port(self):
830
 
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
831
 
        self.assertEquals(('http', None, None, '1:2:3::40', 80, '/one'),
832
 
            parsed)
833
 
 
834
 
 
835
 
class TestURL(TestCase):
836
 
 
837
 
    def test_parse_simple(self):
838
 
        parsed = urlutils.URL.from_string('http://example.com:80/one')
839
 
        self.assertEquals('http', parsed.scheme)
840
 
        self.assertIs(None, parsed.user)
841
 
        self.assertIs(None, parsed.password)
842
 
        self.assertEquals('example.com', parsed.host)
843
 
        self.assertEquals(80, parsed.port)
844
 
        self.assertEquals('/one', parsed.path)
845
 
 
846
 
    def test_ipv6(self):
847
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
848
 
        self.assertEquals('http', parsed.scheme)
849
 
        self.assertIs(None, parsed.port)
850
 
        self.assertIs(None, parsed.user)
851
 
        self.assertIs(None, parsed.password)
852
 
        self.assertEquals('1:2:3::40', parsed.host)
853
 
        self.assertEquals('/one', parsed.path)
854
 
 
855
 
    def test_ipv6_port(self):
856
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
857
 
        self.assertEquals('http', parsed.scheme)
858
 
        self.assertEquals('1:2:3::40', parsed.host)
859
 
        self.assertIs(None, parsed.user)
860
 
        self.assertIs(None, parsed.password)
861
 
        self.assertEquals(80, parsed.port)
862
 
        self.assertEquals('/one', parsed.path)
863
 
 
864
 
    def test_quoted(self):
865
 
        parsed = urlutils.URL.from_string(
866
 
            'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
867
 
        self.assertEquals(parsed.quoted_host, 'ex%41mple.com')
868
 
        self.assertEquals(parsed.host, 'exAmple.com')
869
 
        self.assertEquals(parsed.port, 2222)
870
 
        self.assertEquals(parsed.quoted_user, 'ro%62ey')
871
 
        self.assertEquals(parsed.user, 'robey')
872
 
        self.assertEquals(parsed.quoted_password, 'h%40t')
873
 
        self.assertEquals(parsed.password, 'h@t')
874
 
        self.assertEquals(parsed.path, '/path')
875
 
 
876
 
    def test_eq(self):
877
 
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
878
 
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
879
 
        self.assertEquals(parsed1, parsed2)
880
 
        self.assertEquals(parsed1, parsed1)
881
 
        parsed2.path = '/two'
882
 
        self.assertNotEquals(parsed1, parsed2)
883
 
 
884
 
    def test_repr(self):
885
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
886
 
        self.assertEquals(
887
 
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
888
 
            repr(parsed))
889
 
 
890
 
    def test_str(self):
891
 
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
892
 
        self.assertEquals('http://[1:2:3::40]:80/one', str(parsed))
893
 
 
894
 
    def test__combine_paths(self):
895
 
        combine = urlutils.URL._combine_paths
896
 
        self.assertEqual('/home/sarah/project/foo',
897
 
                         combine('/home/sarah', 'project/foo'))
898
 
        self.assertEqual('/etc',
899
 
                         combine('/home/sarah', '../../etc'))
900
 
        self.assertEqual('/etc',
901
 
                         combine('/home/sarah', '../../../etc'))
902
 
        self.assertEqual('/etc',
903
 
                         combine('/home/sarah', '/etc'))
904
 
 
905
 
    def test_clone(self):
906
 
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
907
 
        url1 = url.clone("two")
908
 
        self.assertEquals("/one/two", url1.path)
909
 
        url2 = url.clone("/two")
910
 
        self.assertEquals("/two", url2.path)
911
 
        url3 = url.clone()
912
 
        self.assertIsNot(url, url3)
913
 
        self.assertEquals(url, url3)