~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_urlutils.py

  • Committer: Martin Pool
  • Date: 2005-09-16 04:19:49 UTC
  • Revision ID: mbp@sourcefrog.net-20050916041949-b6a152f4affa4d78
- notes on conversion of existing history to weaves

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005 by Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 
 
17
 
"""Tests for the urlutils wrapper."""
18
 
 
19
 
import os
20
 
import sys
21
 
 
22
 
import bzrlib
23
 
from bzrlib.errors import InvalidURL, InvalidURLJoin
24
 
import bzrlib.urlutils as urlutils
25
 
from bzrlib.tests import TestCaseInTempDir, TestCase, TestSkipped
26
 
 
27
 
 
28
 
class TestUrlToPath(TestCase):
29
 
    
30
 
    def test_basename(self):
31
 
        # bzrlib.urlutils.basename
32
 
        # Test bzrlib.urlutils.split()
33
 
        basename = urlutils.basename
34
 
        if sys.platform == 'win32':
35
 
            self.assertRaises(InvalidURL, basename, 'file:///path/to/foo')
36
 
            self.assertEqual('foo', basename('file:///C|/foo'))
37
 
            self.assertEqual('foo', basename('file:///C:/foo'))
38
 
            self.assertEqual('', basename('file:///C:/'))
39
 
        else:
40
 
            self.assertEqual('foo', basename('file:///foo'))
41
 
            self.assertEqual('', basename('file:///'))
42
 
 
43
 
        self.assertEqual('foo', basename('http://host/path/to/foo'))
44
 
        self.assertEqual('foo', basename('http://host/path/to/foo/'))
45
 
        self.assertEqual('',
46
 
            basename('http://host/path/to/foo/', exclude_trailing_slash=False))
47
 
        self.assertEqual('path', basename('http://host/path'))
48
 
        self.assertEqual('', basename('http://host/'))
49
 
        self.assertEqual('', basename('http://host'))
50
 
        self.assertEqual('path', basename('http:///nohost/path'))
51
 
 
52
 
        self.assertEqual('path', basename('random+scheme://user:pass@ahost:port/path'))
53
 
        self.assertEqual('path', basename('random+scheme://user:pass@ahost:port/path/'))
54
 
        self.assertEqual('', basename('random+scheme://user:pass@ahost:port/'))
55
 
 
56
 
        # relative paths
57
 
        self.assertEqual('foo', basename('path/to/foo'))
58
 
        self.assertEqual('foo', basename('path/to/foo/'))
59
 
        self.assertEqual('', basename('path/to/foo/',
60
 
            exclude_trailing_slash=False))
61
 
        self.assertEqual('foo', basename('path/../foo'))
62
 
        self.assertEqual('foo', basename('../path/foo'))
63
 
 
64
 
    def test_normalize_url_files(self):
65
 
        # Test that local paths are properly normalized
66
 
        normalize_url = urlutils.normalize_url
67
 
 
68
 
        def norm_file(expected, path):
69
 
            url = normalize_url(path)
70
 
            self.assertStartsWith(url, 'file:///')
71
 
            if sys.platform == 'win32':
72
 
                url = url[len('file:///C:'):]
73
 
            else:
74
 
                url = url[len('file://'):]
75
 
 
76
 
            self.assertEndsWith(url, expected)
77
 
 
78
 
        norm_file('path/to/foo', 'path/to/foo')
79
 
        norm_file('/path/to/foo', '/path/to/foo')
80
 
        norm_file('path/to/foo', '../path/to/foo')
81
 
 
82
 
        # Local paths are assumed to *not* be escaped at all
83
 
        try:
84
 
            u'uni/\xb5'.encode(bzrlib.user_encoding)
85
 
        except UnicodeError:
86
 
            # locale cannot handle unicode 
87
 
            pass
88
 
        else:
89
 
            norm_file('uni/%C2%B5', u'uni/\xb5')
90
 
 
91
 
        norm_file('uni/%25C2%25B5', u'uni/%C2%B5')
92
 
        norm_file('uni/%20b', u'uni/ b')
93
 
        # All the crazy characters get escaped in local paths => file:/// urls
94
 
        norm_file('%27%3B/%3F%3A%40%26%3D%2B%24%2C%23%20', "';/?:@&=+$,# ")
95
 
 
96
 
    def test_normalize_url_hybrid(self):
97
 
        # Anything with a scheme:// should be treated as a hybrid url
98
 
        # which changes what characters get escaped.
99
 
        normalize_url = urlutils.normalize_url
100
 
 
101
 
        eq = self.assertEqual
102
 
        eq('file:///foo/', normalize_url(u'file:///foo/'))
103
 
        eq('file:///foo/%20', normalize_url(u'file:///foo/ '))
104
 
        eq('file:///foo/%20', normalize_url(u'file:///foo/%20'))
105
 
        # Don't escape reserved characters
106
 
        eq('file:///ab_c.d-e/%f:?g&h=i+j;k,L#M$',
107
 
            normalize_url('file:///ab_c.d-e/%f:?g&h=i+j;k,L#M$'))
108
 
        eq('http://ab_c.d-e/%f:?g&h=i+j;k,L#M$',
109
 
            normalize_url('http://ab_c.d-e/%f:?g&h=i+j;k,L#M$'))
110
 
 
111
 
        # Escape unicode characters, but not already escaped chars
112
 
        eq('http://host/ab/%C2%B5/%C2%B5',
113
 
            normalize_url(u'http://host/ab/%C2%B5/\xb5'))
114
 
 
115
 
        # Normalize verifies URLs when they are not unicode
116
 
        # (indicating they did not come from the user)
117
 
        self.assertRaises(InvalidURL, normalize_url, 'http://host/\xb5')
118
 
        self.assertRaises(InvalidURL, normalize_url, 'http://host/ ')
119
 
 
120
 
    def test_url_scheme_re(self):
121
 
        # Test paths that may be URLs
122
 
        def test_one(url, scheme_and_path):
123
 
            """Assert that _url_scheme_re correctly matches
124
 
 
125
 
            :param scheme_and_path: The (scheme, path) that should be matched
126
 
                can be None, to indicate it should not match
127
 
            """
128
 
            m = urlutils._url_scheme_re.match(url)
129
 
            if scheme_and_path is None:
130
 
                self.assertEqual(None, m)
131
 
            else:
132
 
                self.assertEqual(scheme_and_path[0], m.group('scheme'))
133
 
                self.assertEqual(scheme_and_path[1], m.group('path'))
134
 
 
135
 
        # Local paths
136
 
        test_one('/path', None)
137
 
        test_one('C:/path', None)
138
 
        test_one('../path/to/foo', None)
139
 
        test_one(u'../path/to/fo\xe5', None)
140
 
 
141
 
        # Real URLS
142
 
        test_one('http://host/path/', ('http', 'host/path/'))
143
 
        test_one('sftp://host/path/to/foo', ('sftp', 'host/path/to/foo'))
144
 
        test_one('file:///usr/bin', ('file', '/usr/bin'))
145
 
        test_one('file:///C:/Windows', ('file', '/C:/Windows'))
146
 
        test_one('file:///C|/Windows', ('file', '/C|/Windows'))
147
 
        test_one(u'readonly+sftp://host/path/\xe5', ('readonly+sftp', u'host/path/\xe5'))
148
 
 
149
 
        # Weird stuff
150
 
        # Can't have slashes or colons in the scheme
151
 
        test_one('/path/to/://foo', None)
152
 
        test_one('path:path://foo', None)
153
 
        # Must have more than one character for scheme
154
 
        test_one('C://foo', None)
155
 
        test_one('ab://foo', ('ab', 'foo'))
156
 
 
157
 
    def test_dirname(self):
158
 
        # Test bzrlib.urlutils.dirname()
159
 
        dirname = urlutils.dirname
160
 
        if sys.platform == 'win32':
161
 
            self.assertRaises(InvalidURL, dirname, 'file:///path/to/foo')
162
 
            self.assertEqual('file:///C|/', dirname('file:///C|/foo'))
163
 
            self.assertEqual('file:///C|/', dirname('file:///C|/'))
164
 
        else:
165
 
            self.assertEqual('file:///', dirname('file:///foo'))
166
 
            self.assertEqual('file:///', dirname('file:///'))
167
 
 
168
 
        self.assertEqual('http://host/path/to', dirname('http://host/path/to/foo'))
169
 
        self.assertEqual('http://host/path/to', dirname('http://host/path/to/foo/'))
170
 
        self.assertEqual('http://host/path/to/foo',
171
 
            dirname('http://host/path/to/foo/', exclude_trailing_slash=False))
172
 
        self.assertEqual('http://host/', dirname('http://host/path'))
173
 
        self.assertEqual('http://host/', dirname('http://host/'))
174
 
        self.assertEqual('http://host', dirname('http://host'))
175
 
        self.assertEqual('http:///nohost', dirname('http:///nohost/path'))
176
 
 
177
 
        self.assertEqual('random+scheme://user:pass@ahost:port/',
178
 
            dirname('random+scheme://user:pass@ahost:port/path'))
179
 
        self.assertEqual('random+scheme://user:pass@ahost:port/',
180
 
            dirname('random+scheme://user:pass@ahost:port/path/'))
181
 
        self.assertEqual('random+scheme://user:pass@ahost:port/',
182
 
            dirname('random+scheme://user:pass@ahost:port/'))
183
 
 
184
 
        # relative paths
185
 
        self.assertEqual('path/to', dirname('path/to/foo'))
186
 
        self.assertEqual('path/to', dirname('path/to/foo/'))
187
 
        self.assertEqual('path/to/foo',
188
 
            dirname('path/to/foo/', exclude_trailing_slash=False))
189
 
        self.assertEqual('path/..', dirname('path/../foo'))
190
 
        self.assertEqual('../path', dirname('../path/foo'))
191
 
 
192
 
    def test_join(self):
193
 
        def test(expected, *args):
194
 
            joined = urlutils.join(*args)
195
 
            self.assertEqual(expected, joined)
196
 
 
197
 
        # Test a single element
198
 
        test('foo', 'foo')
199
 
 
200
 
        # Test relative path joining
201
 
        test('foo/bar', 'foo', 'bar')
202
 
        test('http://foo/bar', 'http://foo', 'bar')
203
 
        test('http://foo/bar', 'http://foo', '.', 'bar')
204
 
        test('http://foo/baz', 'http://foo', 'bar', '../baz')
205
 
        test('http://foo/bar/baz', 'http://foo', 'bar/baz')
206
 
        test('http://foo/baz', 'http://foo', 'bar/../baz')
207
 
 
208
 
        # Absolute paths
209
 
        test('http://bar', 'http://foo', 'http://bar')
210
 
        test('sftp://bzr/foo', 'http://foo', 'bar', 'sftp://bzr/foo')
211
 
        test('file:///bar', 'foo', 'file:///bar')
212
 
        
213
 
        # Invalid joinings
214
 
        # Cannot go above root
215
 
        self.assertRaises(InvalidURLJoin, urlutils.join,
216
 
                'http://foo', '../baz')
217
 
 
218
 
    def test_function_type(self):
219
 
        if sys.platform == 'win32':
220
 
            self.assertEqual(urlutils._win32_local_path_to_url, urlutils.local_path_to_url)
221
 
            self.assertEqual(urlutils._win32_local_path_from_url, urlutils.local_path_from_url)
222
 
        else:
223
 
            self.assertEqual(urlutils._posix_local_path_to_url, urlutils.local_path_to_url)
224
 
            self.assertEqual(urlutils._posix_local_path_from_url, urlutils.local_path_from_url)
225
 
 
226
 
    def test_posix_local_path_to_url(self):
227
 
        to_url = urlutils._posix_local_path_to_url
228
 
        self.assertEqual('file:///path/to/foo',
229
 
            to_url('/path/to/foo'))
230
 
 
231
 
        try:
232
 
            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')
233
 
        except UnicodeError:
234
 
            raise TestSkipped("local encoding cannot handle unicode")
235
 
 
236
 
        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
237
 
 
238
 
    def test_posix_local_path_from_url(self):
239
 
        from_url = urlutils._posix_local_path_from_url
240
 
        self.assertEqual('/path/to/foo',
241
 
            from_url('file:///path/to/foo'))
242
 
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
243
 
            from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
244
 
        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',
245
 
            from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
246
 
 
247
 
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
248
 
 
249
 
    def test_win32_local_path_to_url(self):
250
 
        to_url = urlutils._win32_local_path_to_url
251
 
        self.assertEqual('file:///C:/path/to/foo',
252
 
            to_url('C:/path/to/foo'))
253
 
 
254
 
        try:
255
 
            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')
256
 
        except UnicodeError:
257
 
            raise TestSkipped("local encoding cannot handle unicode")
258
 
 
259
 
        self.assertEqual('file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)
260
 
 
261
 
    def test_win32_local_path_from_url(self):
262
 
        from_url = urlutils._win32_local_path_from_url
263
 
        self.assertEqual('C:/path/to/foo',
264
 
            from_url('file:///C|/path/to/foo'))
265
 
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
266
 
            from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))
267
 
        self.assertEqual(u'D:/path/to/r\xe4ksm\xf6rg\xe5s',
268
 
            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))
269
 
 
270
 
        self.assertRaises(InvalidURL, from_url, '/path/to/foo')
271
 
        # Not a valid _win32 url, no drive letter
272
 
        self.assertRaises(InvalidURL, from_url, 'file:///path/to/foo')
273
 
 
274
 
    def test__win32_extract_drive_letter(self):
275
 
        extract = urlutils._win32_extract_drive_letter
276
 
        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))
277
 
        self.assertEqual(('file:///d|', '/path'), extract('file://', '/d|/path'))
278
 
        self.assertRaises(InvalidURL, extract, 'file://', '/path')
279
 
 
280
 
    def test_split(self):
281
 
        # Test bzrlib.urlutils.split()
282
 
        split = urlutils.split
283
 
        if sys.platform == 'win32':
284
 
            self.assertRaises(InvalidURL, split, 'file:///path/to/foo')
285
 
            self.assertEqual(('file:///C|/', 'foo'), split('file:///C|/foo'))
286
 
            self.assertEqual(('file:///C:/', ''), split('file:///C:/'))
287
 
        else:
288
 
            self.assertEqual(('file:///', 'foo'), split('file:///foo'))
289
 
            self.assertEqual(('file:///', ''), split('file:///'))
290
 
 
291
 
        self.assertEqual(('http://host/path/to', 'foo'), split('http://host/path/to/foo'))
292
 
        self.assertEqual(('http://host/path/to', 'foo'), split('http://host/path/to/foo/'))
293
 
        self.assertEqual(('http://host/path/to/foo', ''),
294
 
            split('http://host/path/to/foo/', exclude_trailing_slash=False))
295
 
        self.assertEqual(('http://host/', 'path'), split('http://host/path'))
296
 
        self.assertEqual(('http://host/', ''), split('http://host/'))
297
 
        self.assertEqual(('http://host', ''), split('http://host'))
298
 
        self.assertEqual(('http:///nohost', 'path'), split('http:///nohost/path'))
299
 
 
300
 
        self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
301
 
            split('random+scheme://user:pass@ahost:port/path'))
302
 
        self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),
303
 
            split('random+scheme://user:pass@ahost:port/path/'))
304
 
        self.assertEqual(('random+scheme://user:pass@ahost:port/', ''),
305
 
            split('random+scheme://user:pass@ahost:port/'))
306
 
 
307
 
        # relative paths
308
 
        self.assertEqual(('path/to', 'foo'), split('path/to/foo'))
309
 
        self.assertEqual(('path/to', 'foo'), split('path/to/foo/'))
310
 
        self.assertEqual(('path/to/foo', ''),
311
 
            split('path/to/foo/', exclude_trailing_slash=False))
312
 
        self.assertEqual(('path/..', 'foo'), split('path/../foo'))
313
 
        self.assertEqual(('../path', 'foo'), split('../path/foo'))
314
 
 
315
 
    def test__win32_strip_local_trailing_slash(self):
316
 
        strip = urlutils._win32_strip_local_trailing_slash
317
 
        self.assertEqual('file://', strip('file://'))
318
 
        self.assertEqual('file:///', strip('file:///'))
319
 
        self.assertEqual('file:///C', strip('file:///C'))
320
 
        self.assertEqual('file:///C:', strip('file:///C:'))
321
 
        self.assertEqual('file:///d|', strip('file:///d|'))
322
 
        self.assertEqual('file:///C:/', strip('file:///C:/'))
323
 
        self.assertEqual('file:///C:/a', strip('file:///C:/a/'))
324
 
 
325
 
    def test_strip_trailing_slash(self):
326
 
        sts = urlutils.strip_trailing_slash
327
 
        if sys.platform == 'win32':
328
 
            self.assertEqual('file:///C|/', sts('file:///C|/'))
329
 
            self.assertEqual('file:///C:/foo', sts('file:///C:/foo'))
330
 
            self.assertEqual('file:///C|/foo', sts('file:///C|/foo/'))
331
 
        else:
332
 
            self.assertEqual('file:///', sts('file:///'))
333
 
            self.assertEqual('file:///foo', sts('file:///foo'))
334
 
            self.assertEqual('file:///foo', sts('file:///foo/'))
335
 
 
336
 
        self.assertEqual('http://host/', sts('http://host/'))
337
 
        self.assertEqual('http://host/foo', sts('http://host/foo'))
338
 
        self.assertEqual('http://host/foo', sts('http://host/foo/'))
339
 
 
340
 
        # No need to fail just because the slash is missing
341
 
        self.assertEqual('http://host', sts('http://host'))
342
 
        # TODO: jam 20060502 Should this raise InvalidURL?
343
 
        self.assertEqual('file://', sts('file://'))
344
 
 
345
 
        self.assertEqual('random+scheme://user:pass@ahost:port/path',
346
 
            sts('random+scheme://user:pass@ahost:port/path'))
347
 
        self.assertEqual('random+scheme://user:pass@ahost:port/path',
348
 
            sts('random+scheme://user:pass@ahost:port/path/'))
349
 
        self.assertEqual('random+scheme://user:pass@ahost:port/',
350
 
            sts('random+scheme://user:pass@ahost:port/'))
351
 
 
352
 
        # Make sure relative paths work too
353
 
        self.assertEqual('path/to/foo', sts('path/to/foo'))
354
 
        self.assertEqual('path/to/foo', sts('path/to/foo/'))
355
 
        self.assertEqual('../to/foo', sts('../to/foo/'))
356
 
        self.assertEqual('path/../foo', sts('path/../foo/'))
357
 
 
358
 
    def test_unescape_for_display_utf8(self):
359
 
        # Test that URLs are converted to nice unicode strings for display
360
 
        def test(expected, url, encoding='utf-8'):
361
 
            disp_url = urlutils.unescape_for_display(url, encoding=encoding)
362
 
            self.assertIsInstance(disp_url, unicode)
363
 
            self.assertEqual(expected, disp_url)
364
 
 
365
 
        test('http://foo', 'http://foo')
366
 
        if sys.platform == 'win32':
367
 
            test('C:/foo/path', 'file:///C|/foo/path')
368
 
            test('C:/foo/path', 'file:///C:/foo/path')
369
 
        else:
370
 
            test('/foo/path', 'file:///foo/path')
371
 
 
372
 
        test('http://foo/%2Fbaz', 'http://foo/%2Fbaz')
373
 
        test(u'http://host/r\xe4ksm\xf6rg\xe5s',
374
 
             'http://host/r%C3%A4ksm%C3%B6rg%C3%A5s')
375
 
 
376
 
        # Make sure special escaped characters stay escaped
377
 
        test(u'http://host/%3B%2F%3F%3A%40%26%3D%2B%24%2C%23',
378
 
             'http://host/%3B%2F%3F%3A%40%26%3D%2B%24%2C%23')
379
 
 
380
 
        # Can we handle sections that don't have utf-8 encoding?
381
 
        test(u'http://host/%EE%EE%EE/r\xe4ksm\xf6rg\xe5s',
382
 
             'http://host/%EE%EE%EE/r%C3%A4ksm%C3%B6rg%C3%A5s')
383
 
 
384
 
        # Test encoding into output that can handle some characters
385
 
        test(u'http://host/%EE%EE%EE/r\xe4ksm\xf6rg\xe5s',
386
 
             'http://host/%EE%EE%EE/r%C3%A4ksm%C3%B6rg%C3%A5s',
387
 
             encoding='iso-8859-1')
388
 
 
389
 
        # This one can be encoded into utf8
390
 
        test(u'http://host/\u062c\u0648\u062c\u0648',
391
 
             'http://host/%d8%ac%d9%88%d8%ac%d9%88',
392
 
             encoding='utf-8')
393
 
 
394
 
        # This can't be put into 8859-1 and so stays as escapes
395
 
        test(u'http://host/%d8%ac%d9%88%d8%ac%d9%88',
396
 
             'http://host/%d8%ac%d9%88%d8%ac%d9%88',
397
 
             encoding='iso-8859-1')
398
 
 
399
 
    def test_escape(self):
400
 
        self.assertEqual('%25', urlutils.escape('%'))
401
 
        self.assertEqual('%C3%A5', urlutils.escape(u'\xe5'))
402
 
 
403
 
    def test_unescape(self):
404
 
        self.assertEqual('%', urlutils.unescape('%25'))
405
 
        self.assertEqual(u'\xe5', urlutils.unescape('%C3%A5'))
406
 
 
407
 
        self.assertRaises(InvalidURL, urlutils.unescape, u'\xe5')
408
 
        self.assertRaises(InvalidURL, urlutils.unescape, '\xe5')
409
 
        self.assertRaises(InvalidURL, urlutils.unescape, '%E5')
410
 
 
411
 
    def test_escape_unescape(self):
412
 
        self.assertEqual(u'\xe5', urlutils.unescape(urlutils.escape(u'\xe5')))
413
 
        self.assertEqual('%', urlutils.unescape(urlutils.escape('%')))
414
 
 
415
 
    def test_relative_url(self):
416
 
        def test(expected, base, other):
417
 
            result = urlutils.relative_url(base, other)
418
 
            self.assertEqual(expected, result)
419
 
            
420
 
        test('a', 'http://host/', 'http://host/a')
421
 
        test('http://entirely/different', 'sftp://host/branch',
422
 
                    'http://entirely/different')
423
 
        test('../person/feature', 'http://host/branch/mainline',
424
 
                    'http://host/branch/person/feature')
425
 
        test('..', 'http://host/branch', 'http://host/')
426
 
        test('http://host2/branch', 'http://host1/branch', 'http://host2/branch')
427
 
        test('.', 'http://host1/branch', 'http://host1/branch')
428
 
        test('../../../branch/2b', 'file:///home/jelmer/foo/bar/2b',
429
 
                    'file:///home/jelmer/branch/2b')
430
 
        test('../../branch/2b', 'sftp://host/home/jelmer/bar/2b',
431
 
                    'sftp://host/home/jelmer/branch/2b')
432
 
        test('../../branch/feature/%2b', 'http://host/home/jelmer/bar/%2b',
433
 
                    'http://host/home/jelmer/branch/feature/%2b')
434
 
        test('../../branch/feature/2b', 'http://host/home/jelmer/bar/2b/', 
435
 
                    'http://host/home/jelmer/branch/feature/2b')
436
 
        # relative_url should preserve a trailing slash
437
 
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b/',
438
 
                    'http://host/home/jelmer/branch/feature/2b/')
439
 
        test('../../branch/feature/2b/', 'http://host/home/jelmer/bar/2b',
440
 
                    'http://host/home/jelmer/branch/feature/2b/')
441
 
 
442
 
        # TODO: treat http://host as http://host/
443
 
        #       relative_url is typically called from a branch.base or
444
 
        #       transport.base which always ends with a /
445
 
        #test('a', 'http://host', 'http://host/a')
446
 
        test('http://host/a', 'http://host', 'http://host/a')
447
 
        #test('.', 'http://host', 'http://host/')
448
 
        test('http://host/', 'http://host', 'http://host/')
449
 
        #test('.', 'http://host/', 'http://host')
450
 
        test('http://host', 'http://host/', 'http://host')