← 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: Jelmer Vernooij
  • Date: 2011-12-05 14:12:23 UTC
  • mto: This revision was merged to the branch mainline in revision 6348.
  • Revision ID: jelmer@samba.org-20111205141223-8qxae4h37satlzgq
Move more functionality to vf_search.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_urlutils.py
1
 
# Copyright (C) 2005 Canonical Ltd
 
1
# Copyright (C) 2006-2010 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
20
20
import sys
21
21
 
22
22
from bzrlib import osutils, urlutils, win32utils
23
 
from bzrlib.errors import InvalidURL, InvalidURLJoin, InvalidRebaseURLs
 
23
from bzrlib.errors import (
 
24
    InvalidURL,
 
25
    InvalidURLJoin,
 
26
    InvalidRebaseURLs,
 
27
    PathNotChild,
 
28
    )
24
29
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
25
30
 
26
31
 
156
161
        # Weird stuff
157
162
        # Can't have slashes or colons in the scheme
158
163
        test_one('/path/to/://foo', None)
159
 
        test_one('path:path://foo', None)
 
164
        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))
160
165
        # Must have more than one character for scheme
161
166
        test_one('C://foo', None)
162
167
        test_one('ab://foo', ('ab', 'foo'))
195
200
            dirname('path/to/foo/', exclude_trailing_slash=False))
196
201
        self.assertEqual('path/..', dirname('path/../foo'))
197
202
        self.assertEqual('../path', dirname('../path/foo'))
 
203
    
 
204
    def test_is_url(self):
 
205
        self.assertTrue(urlutils.is_url('http://foo/bar'))
 
206
        self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))
 
207
        self.assertTrue(urlutils.is_url('lp:foo/bar'))
 
208
        self.assertTrue(urlutils.is_url('file:///foo/bar'))
 
209
        self.assertFalse(urlutils.is_url(''))
 
210
        self.assertFalse(urlutils.is_url('foo'))
 
211
        self.assertFalse(urlutils.is_url('foo/bar'))
 
212
        self.assertFalse(urlutils.is_url('/foo'))
 
213
        self.assertFalse(urlutils.is_url('/foo/bar'))
 
214
        self.assertFalse(urlutils.is_url('C:/'))
 
215
        self.assertFalse(urlutils.is_url('C:/foo'))
 
216
        self.assertFalse(urlutils.is_url('C:/foo/bar'))
198
217
 
199
218
    def test_join(self):
200
219
        def test(expected, *args):
210
229
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
211
230
        test('http://foo/baz', 'http://foo', 'bar/../baz')
212
231
        test('http://foo/baz', 'http://foo/bar/', '../baz')
 
232
        test('lp:foo/bar', 'lp:foo', 'bar')
 
233
        test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')
213
234
 
214
235
        # Absolute paths
215
236
        test('http://foo', 'http://foo') # abs url with nothing is preserved.
219
240
        test('http://bar/', 'http://foo', 'http://bar/')
220
241
        test('http://bar/a', 'http://foo', 'http://bar/a')
221
242
        test('http://bar/a/', 'http://foo', 'http://bar/a/')
 
243
        test('lp:bar', 'http://foo', 'lp:bar')
 
244
        test('lp:bar', 'lp:foo', 'lp:bar')
 
245
        test('file:///stuff', 'lp:foo', 'file:///stuff')
222
246
 
223
247
        # From a base path
224
248
        test('file:///foo', 'file:///', 'foo')
270
294
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '..')
271
295
        self.assertRaises(InvalidURLJoin, urlutils.joinpath, '/', '/..')
272
296
 
 
297
    def test_join_segment_parameters_raw(self):
 
298
        join_segment_parameters_raw = urlutils.join_segment_parameters_raw
 
299
        self.assertEquals("/somedir/path", 
 
300
            join_segment_parameters_raw("/somedir/path"))
 
301
        self.assertEquals("/somedir/path,rawdata", 
 
302
            join_segment_parameters_raw("/somedir/path", "rawdata"))
 
303
        self.assertRaises(InvalidURLJoin,
 
304
            join_segment_parameters_raw, "/somedir/path",
 
305
                "rawdata1,rawdata2,rawdata3")
 
306
        self.assertEquals("/somedir/path,bla,bar",
 
307
            join_segment_parameters_raw("/somedir/path", "bla", "bar"))
 
308
        self.assertEquals("/somedir,exist=some/path,bla,bar",
 
309
            join_segment_parameters_raw("/somedir,exist=some/path",
 
310
                "bla", "bar"))
 
311
        self.assertRaises(TypeError, join_segment_parameters_raw, 
 
312
            "/somepath", 42)
 
313
 
 
314
    def test_join_segment_parameters(self):
 
315
        join_segment_parameters = urlutils.join_segment_parameters
 
316
        self.assertEquals("/somedir/path", 
 
317
            join_segment_parameters("/somedir/path", {}))
 
318
        self.assertEquals("/somedir/path,key1=val1", 
 
319
            join_segment_parameters("/somedir/path", {"key1": "val1"}))
 
320
        self.assertRaises(InvalidURLJoin,
 
321
            join_segment_parameters, "/somedir/path",
 
322
            {"branch": "brr,brr,brr"})
 
323
        self.assertRaises(InvalidURLJoin,
 
324
            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})
 
325
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
 
326
            join_segment_parameters("/somedir/path", {
 
327
                "key1": "val1", "key2": "val2"}))
 
328
        self.assertEquals("/somedir/path,key1=val1,key2=val2",
 
329
            join_segment_parameters("/somedir/path,key1=val1", {
 
330
                "key2": "val2"}))
 
331
        self.assertEquals("/somedir/path,key1=val2",
 
332
            join_segment_parameters("/somedir/path,key1=val1", {
 
333
                "key1": "val2"}))
 
334
        self.assertEquals("/somedir,exist=some/path,key1=val1",
 
335
            join_segment_parameters("/somedir,exist=some/path",
 
336
                {"key1": "val1"}))
 
337
        self.assertEquals("/,key1=val1,key2=val2",
 
338
            join_segment_parameters("/,key1=val1", {"key2": "val2"}))
 
339
        self.assertRaises(TypeError,
 
340
            join_segment_parameters, "/,key1=val1", {"foo": 42})
 
341
 
273
342
    def test_function_type(self):
274
343
        if sys.platform == 'win32':
275
 
            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
276
 
            self.assertEqual(urlutils._win32_local_path_from_url, urlutils.local_path_from_url)
 
344
            self.assertEqual(urlutils._win32_local_path_to_url,
 
345
                urlutils.local_path_to_url)
 
346
            self.assertEqual(urlutils._win32_local_path_from_url,
 
347
                urlutils.local_path_from_url)
277
348
        else:
278
 
            self.assertEqual(urlutils._posix_local_path_to_url, urlutils.local_path_to_url)
279
 
            self.assertEqual(urlutils._posix_local_path_from_url, urlutils.local_path_from_url)
 
349
            self.assertEqual(urlutils._posix_local_path_to_url,
 
350
                urlutils.local_path_to_url)
 
351
            self.assertEqual(urlutils._posix_local_path_from_url,
 
352
                urlutils.local_path_from_url)
280
353
 
281
354
    def test_posix_local_path_to_url(self):
282
355
        to_url = urlutils._posix_local_path_to_url
283
356
        self.assertEqual('file:///path/to/foo',
284
357
            to_url('/path/to/foo'))
285
358
 
 
359
        self.assertEqual('file:///path/to/foo%2Cbar',
 
360
            to_url('/path/to/foo,bar'))
 
361
 
286
362
        try:
287
363
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
288
364
        except UnicodeError:
295
371
        from_url = urlutils._posix_local_path_from_url
296
372
        self.assertEqual('/path/to/foo',
297
373
            from_url('file:///path/to/foo'))
 
374
        self.assertEqual('/path/to/foo',
 
375
            from_url('file:///path/to/foo,branch=foo'))
298
376
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
299
377
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
300
378
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
322
400
 
323
401
        self.assertEqual('file:///', to_url('/'))
324
402
 
 
403
        self.assertEqual('file:///C:/path/to/foo%2Cbar',
 
404
            to_url('C:/path/to/foo,bar'))
325
405
        try:
326
406
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
327
407
        except UnicodeError:
354
434
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
355
435
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
356
436
        self.assertEqual('/', from_url('file:///'))
 
437
        self.assertEqual('C:/path/to/foo',
 
438
            from_url('file:///C|/path/to/foo,branch=foo'))
357
439
 
 
440
        self.assertRaises(InvalidURL, from_url, 'file:///C:')
 
441
        self.assertRaises(InvalidURL, from_url, 'file:///c')
358
442
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
359
443
        # Not a valid _win32 url, no drive letter
360
444
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
362
446
    def test_win32_unc_path_from_url(self):
363
447
        from_url = urlutils._win32_local_path_from_url
364
448
        self.assertEqual('//HOST/path', from_url('file://HOST/path'))
 
449
        self.assertEqual('//HOST/path',
 
450
            from_url('file://HOST/path,branch=foo'))
365
451
        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine
366
452
        # we want to use only 2 slashes
367
453
        # Firefox understand only 5 slashes in URL, but it's ugly
376
462
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
377
463
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
378
464
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
 
465
        # Root drives without slash treated as invalid, see bug #841322
 
466
        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))
 
467
        self.assertRaises(InvalidURL, extract, 'file://', '/C:')
 
468
        # Invalid without drive separator or following forward slash
 
469
        self.assertRaises(InvalidURL, extract, 'file://', '/C')
 
470
        self.assertRaises(InvalidURL, extract, 'file://', '/C:ool')
379
471
 
380
472
    def test_split(self):
381
473
        # Test bzrlib.urlutils.split()
412
504
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
413
505
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
414
506
 
 
507
    def test_split_segment_parameters_raw(self):
 
508
        split_segment_parameters_raw = urlutils.split_segment_parameters_raw
 
509
        # Check relative references with absolute paths
 
510
        self.assertEquals(("/some/path", []),
 
511
            split_segment_parameters_raw("/some/path"))
 
512
        self.assertEquals(("/some/path", ["tip"]),
 
513
            split_segment_parameters_raw("/some/path,tip"))
 
514
        self.assertEquals(("/some,dir/path", ["tip"]),
 
515
            split_segment_parameters_raw("/some,dir/path,tip"))
 
516
        self.assertEquals(("/somedir/path", ["heads%2Ftip"]),
 
517
            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))
 
518
        self.assertEquals(("/somedir/path", ["heads%2Ftip", "bar"]),
 
519
            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))
 
520
        # Check relative references with relative paths
 
521
        self.assertEquals(("", ["key1=val1"]),
 
522
            split_segment_parameters_raw(",key1=val1"))
 
523
        self.assertEquals(("foo/", ["key1=val1"]),
 
524
            split_segment_parameters_raw("foo/,key1=val1"))
 
525
        self.assertEquals(("foo", ["key1=val1"]),
 
526
            split_segment_parameters_raw("foo,key1=val1"))
 
527
        self.assertEquals(("foo/base,la=bla/other/elements", []),
 
528
            split_segment_parameters_raw("foo/base,la=bla/other/elements"))
 
529
        self.assertEquals(("foo/base,la=bla/other/elements", ["a=b"]),
 
530
            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))
 
531
        # TODO: Check full URLs as well as relative references
 
532
 
 
533
    def test_split_segment_parameters(self):
 
534
        split_segment_parameters = urlutils.split_segment_parameters
 
535
        # Check relative references with absolute paths
 
536
        self.assertEquals(("/some/path", {}),
 
537
            split_segment_parameters("/some/path"))
 
538
        self.assertEquals(("/some/path", {"branch": "tip"}),
 
539
            split_segment_parameters("/some/path,branch=tip"))
 
540
        self.assertEquals(("/some,dir/path", {"branch": "tip"}),
 
541
            split_segment_parameters("/some,dir/path,branch=tip"))
 
542
        self.assertEquals(("/somedir/path", {"ref": "heads%2Ftip"}),
 
543
            split_segment_parameters("/somedir/path,ref=heads%2Ftip"))
 
544
        self.assertEquals(("/somedir/path",
 
545
            {"ref": "heads%2Ftip", "key1": "val1"}),
 
546
            split_segment_parameters(
 
547
                "/somedir/path,ref=heads%2Ftip,key1=val1"))
 
548
        self.assertEquals(("/somedir/path", {"ref": "heads%2F=tip"}),
 
549
            split_segment_parameters("/somedir/path,ref=heads%2F=tip"))
 
550
        # Check relative references with relative paths
 
551
        self.assertEquals(("", {"key1": "val1"}),
 
552
            split_segment_parameters(",key1=val1"))
 
553
        self.assertEquals(("foo/", {"key1": "val1"}),
 
554
            split_segment_parameters("foo/,key1=val1"))
 
555
        self.assertEquals(("foo/base,key1=val1/other/elements", {}),
 
556
            split_segment_parameters("foo/base,key1=val1/other/elements"))
 
557
        self.assertEquals(("foo/base,key1=val1/other/elements",
 
558
            {"key2": "val2"}), split_segment_parameters(
 
559
                "foo/base,key1=val1/other/elements,key2=val2"))
 
560
        # TODO: Check full URLs as well as relative references
 
561
 
415
562
    def test_win32_strip_local_trailing_slash(self):
416
563
        strip = urlutils._win32_strip_local_trailing_slash
417
564
        self.assertEqual('file://', strip('file://'))
680
827
 
681
828
class TestParseURL(TestCase):
682
829
 
683
 
    def test_parse_url(self):
684
 
        self.assertEqual(urlutils.parse_url('http://example.com:80/one'),
685
 
            ('http', None, None, 'example.com', 80, '/one'))
686
 
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]/one'),
687
 
                ('http', None, None, '1:2:3::40', None, '/one'))
688
 
        self.assertEqual(urlutils.parse_url('http://[1:2:3::40]:80/one'),
689
 
                ('http', None, None, '1:2:3::40', 80, '/one'))
 
830
    def test_parse_simple(self):
 
831
        parsed = urlutils.parse_url('http://example.com:80/one')
 
832
        self.assertEquals(('http', None, None, 'example.com', 80, '/one'),
 
833
            parsed)
 
834
 
 
835
    def test_ipv6(self):
 
836
        parsed = urlutils.parse_url('http://[1:2:3::40]/one')
 
837
        self.assertEquals(('http', None, None, '1:2:3::40', None, '/one'),
 
838
            parsed)
 
839
 
 
840
    def test_ipv6_port(self):
 
841
        parsed = urlutils.parse_url('http://[1:2:3::40]:80/one')
 
842
        self.assertEquals(('http', None, None, '1:2:3::40', 80, '/one'),
 
843
            parsed)
 
844
 
 
845
 
 
846
class TestURL(TestCase):
 
847
 
 
848
    def test_parse_simple(self):
 
849
        parsed = urlutils.URL.from_string('http://example.com:80/one')
 
850
        self.assertEquals('http', parsed.scheme)
 
851
        self.assertIs(None, parsed.user)
 
852
        self.assertIs(None, parsed.password)
 
853
        self.assertEquals('example.com', parsed.host)
 
854
        self.assertEquals(80, parsed.port)
 
855
        self.assertEquals('/one', parsed.path)
 
856
 
 
857
    def test_ipv6(self):
 
858
        parsed = urlutils.URL.from_string('http://[1:2:3::40]/one')
 
859
        self.assertEquals('http', parsed.scheme)
 
860
        self.assertIs(None, parsed.port)
 
861
        self.assertIs(None, parsed.user)
 
862
        self.assertIs(None, parsed.password)
 
863
        self.assertEquals('1:2:3::40', parsed.host)
 
864
        self.assertEquals('/one', parsed.path)
 
865
 
 
866
    def test_ipv6_port(self):
 
867
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
868
        self.assertEquals('http', parsed.scheme)
 
869
        self.assertEquals('1:2:3::40', parsed.host)
 
870
        self.assertIs(None, parsed.user)
 
871
        self.assertIs(None, parsed.password)
 
872
        self.assertEquals(80, parsed.port)
 
873
        self.assertEquals('/one', parsed.path)
 
874
 
 
875
    def test_quoted(self):
 
876
        parsed = urlutils.URL.from_string(
 
877
            'http://ro%62ey:h%40t@ex%41mple.com:2222/path')
 
878
        self.assertEquals(parsed.quoted_host, 'ex%41mple.com')
 
879
        self.assertEquals(parsed.host, 'exAmple.com')
 
880
        self.assertEquals(parsed.port, 2222)
 
881
        self.assertEquals(parsed.quoted_user, 'ro%62ey')
 
882
        self.assertEquals(parsed.user, 'robey')
 
883
        self.assertEquals(parsed.quoted_password, 'h%40t')
 
884
        self.assertEquals(parsed.password, 'h@t')
 
885
        self.assertEquals(parsed.path, '/path')
 
886
 
 
887
    def test_eq(self):
 
888
        parsed1 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
889
        parsed2 = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
890
        self.assertEquals(parsed1, parsed2)
 
891
        self.assertEquals(parsed1, parsed1)
 
892
        parsed2.path = '/two'
 
893
        self.assertNotEquals(parsed1, parsed2)
 
894
 
 
895
    def test_repr(self):
 
896
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
897
        self.assertEquals(
 
898
            "<URL('http', None, None, '1:2:3::40', 80, '/one')>",
 
899
            repr(parsed))
 
900
 
 
901
    def test_str(self):
 
902
        parsed = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
903
        self.assertEquals('http://[1:2:3::40]:80/one', str(parsed))
 
904
 
 
905
    def test__combine_paths(self):
 
906
        combine = urlutils.URL._combine_paths
 
907
        self.assertEqual('/home/sarah/project/foo',
 
908
                         combine('/home/sarah', 'project/foo'))
 
909
        self.assertEqual('/etc',
 
910
                         combine('/home/sarah', '../../etc'))
 
911
        self.assertEqual('/etc',
 
912
                         combine('/home/sarah', '../../../etc'))
 
913
        self.assertEqual('/etc',
 
914
                         combine('/home/sarah', '/etc'))
 
915
 
 
916
    def test_clone(self):
 
917
        url = urlutils.URL.from_string('http://[1:2:3::40]:80/one')
 
918
        url1 = url.clone("two")
 
919
        self.assertEquals("/one/two", url1.path)
 
920
        url2 = url.clone("/two")
 
921
        self.assertEquals("/two", url2.path)
 
922
        url3 = url.clone()
 
923
        self.assertIsNot(url, url3)
 
924
        self.assertEquals(url, url3)
 
925
 
 
926
 
 
927
class TestFileRelpath(TestCase):
 
928
 
 
929
    # GZ 2011-11-18: A way to override all path handling functions to one
 
930
    #                platform or another for testing would be nice.
 
931
 
 
932
    def _with_posix_paths(self):
 
933
        self.overrideAttr(urlutils, "local_path_from_url",
 
934
            urlutils._posix_local_path_from_url)
 
935
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH", len("file:///"))
 
936
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
 
937
        self.overrideAttr(osutils, "abspath", osutils._posix_abspath)
 
938
        self.overrideAttr(osutils, "normpath", osutils._posix_normpath)
 
939
        self.overrideAttr(osutils, "pathjoin", osutils.posixpath.join)
 
940
        self.overrideAttr(osutils, "split", osutils.posixpath.split)
 
941
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 1)
 
942
 
 
943
    def _with_win32_paths(self):
 
944
        self.overrideAttr(urlutils, "local_path_from_url",
 
945
            urlutils._win32_local_path_from_url)
 
946
        self.overrideAttr(urlutils, "MIN_ABS_FILEURL_LENGTH",
 
947
            urlutils.WIN32_MIN_ABS_FILEURL_LENGTH)
 
948
        self.overrideAttr(osutils, "abspath", osutils._win32_abspath)
 
949
        self.overrideAttr(osutils, "normpath", osutils._win32_normpath)
 
950
        self.overrideAttr(osutils, "pathjoin", osutils._win32_pathjoin)
 
951
        self.overrideAttr(osutils, "split", osutils.ntpath.split)
 
952
        self.overrideAttr(osutils, "MIN_ABS_PATHLENGTH", 3)
 
953
 
 
954
    def test_same_url_posix(self):
 
955
        self._with_posix_paths()
 
956
        self.assertEquals("",
 
957
            urlutils.file_relpath("file:///a", "file:///a"))
 
958
        self.assertEquals("",
 
959
            urlutils.file_relpath("file:///a", "file:///a/"))
 
960
        self.assertEquals("",
 
961
            urlutils.file_relpath("file:///a/", "file:///a"))
 
962
 
 
963
    def test_same_url_win32(self):
 
964
        self._with_win32_paths()
 
965
        self.assertEquals("",
 
966
            urlutils.file_relpath("file:///A:/", "file:///A:/"))
 
967
        self.assertEquals("",
 
968
            urlutils.file_relpath("file:///A|/", "file:///A:/"))
 
969
        self.assertEquals("",
 
970
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/"))
 
971
        self.assertEquals("",
 
972
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/"))
 
973
        self.assertEquals("",
 
974
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b"))
 
975
 
 
976
    def test_child_posix(self):
 
977
        self._with_posix_paths()
 
978
        self.assertEquals("b",
 
979
            urlutils.file_relpath("file:///a", "file:///a/b"))
 
980
        self.assertEquals("b",
 
981
            urlutils.file_relpath("file:///a/", "file:///a/b"))
 
982
        self.assertEquals("b/c",
 
983
            urlutils.file_relpath("file:///a", "file:///a/b/c"))
 
984
 
 
985
    def test_child_win32(self):
 
986
        self._with_win32_paths()
 
987
        self.assertEquals("b",
 
988
            urlutils.file_relpath("file:///A:/", "file:///A:/b"))
 
989
        self.assertEquals("b",
 
990
            urlutils.file_relpath("file:///A|/", "file:///A:/b"))
 
991
        self.assertEquals("c",
 
992
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c"))
 
993
        self.assertEquals("c",
 
994
            urlutils.file_relpath("file:///A:/b/", "file:///A:/b/c"))
 
995
        self.assertEquals("c/d",
 
996
            urlutils.file_relpath("file:///A:/b", "file:///A:/b/c/d"))
 
997
 
 
998
    def test_sibling_posix(self):
 
999
        self._with_posix_paths()
 
1000
        self.assertRaises(PathNotChild,
 
1001
            urlutils.file_relpath, "file:///a/b", "file:///a/c")
 
1002
        self.assertRaises(PathNotChild,
 
1003
            urlutils.file_relpath, "file:///a/b/", "file:///a/c")
 
1004
        self.assertRaises(PathNotChild,
 
1005
            urlutils.file_relpath, "file:///a/b/", "file:///a/c/")
 
1006
 
 
1007
    def test_sibling_win32(self):
 
1008
        self._with_win32_paths()
 
1009
        self.assertRaises(PathNotChild,
 
1010
            urlutils.file_relpath, "file:///A:/b", "file:///A:/c")
 
1011
        self.assertRaises(PathNotChild,
 
1012
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c")
 
1013
        self.assertRaises(PathNotChild,
 
1014
            urlutils.file_relpath, "file:///A:/b/", "file:///A:/c/")
 
1015
 
 
1016
    def test_parent_posix(self):
 
1017
        self._with_posix_paths()
 
1018
        self.assertRaises(PathNotChild,
 
1019
            urlutils.file_relpath, "file:///a/b", "file:///a")
 
1020
        self.assertRaises(PathNotChild,
 
1021
            urlutils.file_relpath, "file:///a/b", "file:///a/")
 
1022
 
 
1023
    def test_parent_win32(self):
 
1024
        self._with_win32_paths()
 
1025
        self.assertRaises(PathNotChild,
 
1026
            urlutils.file_relpath, "file:///A:/b", "file:///A:/")
 
1027
        self.assertRaises(PathNotChild,
 
1028
            urlutils.file_relpath, "file:///A:/b/c", "file:///A:/b")