/brz/remove-bazaar

# Copyright (C) 2006-2012, 2015, 2016 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

"""Tests for the urlutils wrapper."""

import os

import sys

from .. import osutils, urlutils

from ..errors import (

    PathNotChild,

    )

from . import features, TestCaseInTempDir, TestCase, TestSkipped

class TestUrlToPath(TestCase):

    def test_basename(self):

        # breezy.urlutils.basename

        # Test breezy.urlutils.split()

        basename = urlutils.basename

        if sys.platform == 'win32':

            self.assertRaises(urlutils.InvalidURL, basename,

                              'file:///path/to/foo')

            self.assertEqual('foo', basename('file:///C|/foo'))

            self.assertEqual('foo', basename('file:///C:/foo'))

            self.assertEqual('', basename('file:///C:/'))

        else:

            self.assertEqual('foo', basename('file:///foo'))

            self.assertEqual('', basename('file:///'))

        self.assertEqual('foo', basename('http://host/path/to/foo'))

        self.assertEqual('foo', basename('http://host/path/to/foo/'))

        self.assertEqual(

            '', basename('http://host/path/to/foo/',

                         exclude_trailing_slash=False))

        self.assertEqual('path', basename('http://host/path'))

        self.assertEqual('', basename('http://host/'))

        self.assertEqual('', basename('http://host'))

        self.assertEqual('path', basename('http:///nohost/path'))

        self.assertEqual('path', basename(

            'random+scheme://user:pass@ahost:port/path'))

        self.assertEqual('path', basename(

            'random+scheme://user:pass@ahost:port/path/'))

        self.assertEqual('', basename('random+scheme://user:pass@ahost:port/'))

        # relative paths

        self.assertEqual('foo', basename('path/to/foo'))

        self.assertEqual('foo', basename('path/to/foo/'))

        self.assertEqual('', basename('path/to/foo/',

                                      exclude_trailing_slash=False))

        self.assertEqual('foo', basename('path/../foo'))

        self.assertEqual('foo', basename('../path/foo'))

    def test_normalize_url_files(self):

        # Test that local paths are properly normalized

        normalize_url = urlutils.normalize_url

        def norm_file(expected, path):

            url = normalize_url(path)

            self.assertStartsWith(url, 'file:///')

            if sys.platform == 'win32':

                url = url[len('file:///C:'):]

            else:

                url = url[len('file://'):]

            self.assertEndsWith(url, expected)

        norm_file('path/to/foo', 'path/to/foo')

        norm_file('/path/to/foo', '/path/to/foo')

        norm_file('path/to/foo', '../path/to/foo')

        # Local paths are assumed to *not* be escaped at all

        try:

            u'uni/\xb5'.encode(osutils.get_user_encoding())

        except UnicodeError:

            # locale cannot handle unicode

            pass

        else:

            norm_file('uni/%C2%B5', u'uni/\xb5')

        norm_file('uni/%25C2%25B5', u'uni/%C2%B5')

        norm_file('uni/%20b', u'uni/ b')

        # All the crazy characters get escaped in local paths => file:/// urls

        # The ' ' character must not be at the end, because on win32

        # it gets stripped off by ntpath.abspath

        norm_file('%27%20%3B/%3F%3A%40%26%3D%2B%24%2C%23', "' ;/?:@&=+$,#")

    def test_normalize_url_hybrid(self):

        # Anything with a scheme:// should be treated as a hybrid url

        # which changes what characters get escaped.

        normalize_url = urlutils.normalize_url

        eq = self.assertEqual

        eq('file:///foo/', normalize_url(u'file:///foo/'))

        eq('file:///foo/%20', normalize_url(u'file:///foo/ '))

        eq('file:///foo/%20', normalize_url(u'file:///foo/%20'))

        # Don't escape reserved characters

        eq('file:///ab_c.d-e/%f:?g&h=i+j;k,L#M$',

            normalize_url('file:///ab_c.d-e/%f:?g&h=i+j;k,L#M$'))

        eq('http://ab_c.d-e/%f:?g&h=i+j;k,L#M$',

            normalize_url('http://ab_c.d-e/%f:?g&h=i+j;k,L#M$'))

        # Escape unicode characters, but not already escaped chars

        eq('http://host/ab/%C2%B5/%C2%B5',

            normalize_url(u'http://host/ab/%C2%B5/\xb5'))

        # Unescape characters that don't need to be escaped

        eq('http://host/~bob%2525-._',

           normalize_url('http://host/%7Ebob%2525%2D%2E%5F'))

        eq('http://host/~bob%2525-._',

           normalize_url(u'http://host/%7Ebob%2525%2D%2E%5F'))

    def test_url_scheme_re(self):

        # Test paths that may be URLs

        def test_one(url, scheme_and_path):

            """Assert that _url_scheme_re correctly matches

            :param scheme_and_path: The (scheme, path) that should be matched

                can be None, to indicate it should not match

            """

            m = urlutils._url_scheme_re.match(url)

            if scheme_and_path is None:

                self.assertEqual(None, m)

            else:

                self.assertEqual(scheme_and_path[0], m.group('scheme'))

                self.assertEqual(scheme_and_path[1], m.group('path'))

        # Local paths

        test_one('/path', None)

        test_one('C:/path', None)

        test_one('../path/to/foo', None)

        test_one(u'../path/to/fo\xe5', None)

        # Real URLS

        test_one('http://host/path/', ('http', 'host/path/'))

        test_one('sftp://host/path/to/foo', ('sftp', 'host/path/to/foo'))

        test_one('file:///usr/bin', ('file', '/usr/bin'))

        test_one('file:///C:/Windows', ('file', '/C:/Windows'))

        test_one('file:///C|/Windows', ('file', '/C|/Windows'))

        test_one(u'readonly+sftp://host/path/\xe5',

                 ('readonly+sftp', u'host/path/\xe5'))

        # Weird stuff

        # Can't have slashes or colons in the scheme

        test_one('/path/to/://foo', None)

        test_one('scheme:stuff://foo', ('scheme', 'stuff://foo'))

        # Must have more than one character for scheme

        test_one('C://foo', None)

        test_one('ab://foo', ('ab', 'foo'))

    def test_dirname(self):

        # Test breezy.urlutils.dirname()

        dirname = urlutils.dirname

        if sys.platform == 'win32':

            self.assertRaises(urlutils.InvalidURL, dirname,

                              'file:///path/to/foo')

            self.assertEqual('file:///C|/', dirname('file:///C|/foo'))

            self.assertEqual('file:///C|/', dirname('file:///C|/'))

        else:

            self.assertEqual('file:///', dirname('file:///foo'))

            self.assertEqual('file:///', dirname('file:///'))

        self.assertEqual('http://host/path/to',

                         dirname('http://host/path/to/foo'))

        self.assertEqual('http://host/path/to',

                         dirname('http://host/path/to/foo/'))

        self.assertEqual('http://host/path/to/foo',

                         dirname('http://host/path/to/foo/',

                                 exclude_trailing_slash=False))

        self.assertEqual('http://host/', dirname('http://host/path'))

        self.assertEqual('http://host/', dirname('http://host/'))

        self.assertEqual('http://host', dirname('http://host'))

        self.assertEqual('http:///nohost', dirname('http:///nohost/path'))

        self.assertEqual('random+scheme://user:pass@ahost:port/',

                         dirname('random+scheme://user:pass@ahost:port/path'))

        self.assertEqual('random+scheme://user:pass@ahost:port/',

                         dirname('random+scheme://user:pass@ahost:port/path/'))

        self.assertEqual('random+scheme://user:pass@ahost:port/',

                         dirname('random+scheme://user:pass@ahost:port/'))

        # relative paths

        self.assertEqual('path/to', dirname('path/to/foo'))

        self.assertEqual('path/to', dirname('path/to/foo/'))

        self.assertEqual('path/to/foo',

                         dirname('path/to/foo/', exclude_trailing_slash=False))

        self.assertEqual('path/..', dirname('path/../foo'))

        self.assertEqual('../path', dirname('../path/foo'))

    def test_is_url(self):

        self.assertTrue(urlutils.is_url('http://foo/bar'))

        self.assertTrue(urlutils.is_url('bzr+ssh://foo/bar'))

        self.assertTrue(urlutils.is_url('lp:foo/bar'))

        self.assertTrue(urlutils.is_url('file:///foo/bar'))

        self.assertFalse(urlutils.is_url(''))

        self.assertFalse(urlutils.is_url('foo'))

        self.assertFalse(urlutils.is_url('foo/bar'))

        self.assertFalse(urlutils.is_url('/foo'))

        self.assertFalse(urlutils.is_url('/foo/bar'))

        self.assertFalse(urlutils.is_url('C:/'))

        self.assertFalse(urlutils.is_url('C:/foo'))

        self.assertFalse(urlutils.is_url('C:/foo/bar'))

    def test_join(self):

        def test(expected, *args):

            joined = urlutils.join(*args)

            self.assertEqual(expected, joined)

        # Test relative path joining

        test('foo', 'foo')  # relative fragment with nothing is preserved.

        test('foo/bar', 'foo', 'bar')

        test('http://foo/bar', 'http://foo', 'bar')

        test('http://foo/bar', 'http://foo', '.', 'bar')

        test('http://foo/baz', 'http://foo', 'bar', '../baz')

        test('http://foo/bar/baz', 'http://foo', 'bar/baz')

        test('http://foo/baz', 'http://foo', 'bar/../baz')

        test('http://foo/baz', 'http://foo/bar/', '../baz')

        test('lp:foo/bar', 'lp:foo', 'bar')

        test('lp:foo/bar/baz', 'lp:foo', 'bar/baz')

        # Absolute paths

        test('http://foo', 'http://foo')  # abs url with nothing is preserved.

        test('http://bar', 'http://foo', 'http://bar')

        test('sftp://bzr/foo', 'http://foo', 'bar', 'sftp://bzr/foo')

        test('file:///bar', 'foo', 'file:///bar')

        test('http://bar/', 'http://foo', 'http://bar/')

        test('http://bar/a', 'http://foo', 'http://bar/a')

        test('http://bar/a/', 'http://foo', 'http://bar/a/')

        test('lp:bar', 'http://foo', 'lp:bar')

        test('lp:bar', 'lp:foo', 'lp:bar')

        test('file:///stuff', 'lp:foo', 'file:///stuff')

        # From a base path

        test('file:///foo', 'file:///', 'foo')

        test('file:///bar/foo', 'file:///bar/', 'foo')

        test('http://host/foo', 'http://host/', 'foo')

        test('http://host/', 'http://host', '')

        # Invalid joinings

        # Cannot go above root

        # Implicitly at root:

        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,

                          'http://foo', '../baz')

        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,

                          'http://foo', '/..')

        # Joining from a path explicitly under the root.

        self.assertRaises(urlutils.InvalidURLJoin, urlutils.join,

                          'http://foo/a', '../../b')

    def test_joinpath(self):

        def test(expected, *args):

            joined = urlutils.joinpath(*args)

            self.assertEqual(expected, joined)

        # Test a single element

        test('foo', 'foo')

        # Test relative path joining

        test('foo/bar', 'foo', 'bar')

        test('foo/bar', 'foo', '.', 'bar')

        test('foo/baz', 'foo', 'bar', '../baz')

        test('foo/bar/baz', 'foo', 'bar/baz')

        test('foo/baz', 'foo', 'bar/../baz')

        # Test joining to an absolute path

        test('/foo', '/foo')

        test('/foo', '/foo', '.')

        test('/foo/bar', '/foo', 'bar')

        test('/', '/foo', '..')

        # Test joining with an absolute path

        test('/bar', 'foo', '/bar')

        # Test joining to a path with a trailing slash

        test('foo/bar', 'foo/', 'bar')

        # Invalid joinings

        # Cannot go above root

        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',

                          '../baz')

        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',

                          '..')

        self.assertRaises(urlutils.InvalidURLJoin, urlutils.joinpath, '/',

                          '/..')

    def test_join_segment_parameters_raw(self):

        join_segment_parameters_raw = urlutils.join_segment_parameters_raw

        self.assertEqual("/somedir/path",

                         join_segment_parameters_raw("/somedir/path"))

        self.assertEqual("/somedir/path,rawdata",

                         join_segment_parameters_raw(

                             "/somedir/path", "rawdata"))

        self.assertRaises(urlutils.InvalidURLJoin,

                          join_segment_parameters_raw, "/somedir/path",

                          "rawdata1,rawdata2,rawdata3")

        self.assertEqual("/somedir/path,bla,bar",

                         join_segment_parameters_raw(

                             "/somedir/path", "bla", "bar"))

        self.assertEqual(

            "/somedir,exist=some/path,bla,bar",

            join_segment_parameters_raw("/somedir,exist=some/path",

                                        "bla", "bar"))

        self.assertRaises(TypeError, join_segment_parameters_raw,

                          "/somepath", 42)

    def test_join_segment_parameters(self):

        join_segment_parameters = urlutils.join_segment_parameters

        self.assertEqual("/somedir/path",

                         join_segment_parameters("/somedir/path", {}))

        self.assertEqual(

            "/somedir/path,key1=val1",

            join_segment_parameters("/somedir/path", {"key1": "val1"}))

        self.assertRaises(urlutils.InvalidURLJoin,

                          join_segment_parameters, "/somedir/path",

                          {"branch": "brr,brr,brr"})

        self.assertRaises(

            urlutils.InvalidURLJoin,

            join_segment_parameters, "/somedir/path", {"key1=val1": "val2"})

        self.assertEqual("/somedir/path,key1=val1,key2=val2",

                         join_segment_parameters("/somedir/path", {

                             "key1": "val1", "key2": "val2"}))

        self.assertEqual("/somedir/path,key1=val1,key2=val2",

                         join_segment_parameters("/somedir/path,key1=val1", {

                             "key2": "val2"}))

        self.assertEqual("/somedir/path,key1=val2",

                         join_segment_parameters("/somedir/path,key1=val1", {

                             "key1": "val2"}))

        self.assertEqual("/somedir,exist=some/path,key1=val1",

                         join_segment_parameters("/somedir,exist=some/path",

                                                 {"key1": "val1"}))

        self.assertEqual(

            "/,key1=val1,key2=val2",

            join_segment_parameters("/,key1=val1", {"key2": "val2"}))

        self.assertRaises(TypeError,

                          join_segment_parameters, "/,key1=val1", {"foo": 42})

    def test_function_type(self):

        if sys.platform == 'win32':

            self.assertEqual(urlutils._win32_local_path_to_url,

                             urlutils.local_path_to_url)

            self.assertEqual(urlutils._win32_local_path_from_url,

                             urlutils.local_path_from_url)

        else:

            self.assertEqual(urlutils._posix_local_path_to_url,

                             urlutils.local_path_to_url)

            self.assertEqual(urlutils._posix_local_path_from_url,

                             urlutils.local_path_from_url)

    def test_posix_local_path_to_url(self):

        to_url = urlutils._posix_local_path_to_url

        self.assertEqual('file:///path/to/foo',

                         to_url('/path/to/foo'))

        self.assertEqual('file:///path/to/foo%2Cbar',

                         to_url('/path/to/foo,bar'))

        try:

            result = to_url(u'/path/to/r\xe4ksm\xf6rg\xe5s')

        except UnicodeError:

            raise TestSkipped("local encoding cannot handle unicode")

        self.assertEqual('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)

        self.assertTrue(isinstance(result, str))

    def test_posix_local_path_from_url(self):

        from_url = urlutils._posix_local_path_from_url

        self.assertEqual('/path/to/foo',

                         from_url('file:///path/to/foo'))

        self.assertEqual('/path/to/foo',

                         from_url('file:///path/to/foo,branch=foo'))

        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',

                         from_url('file:///path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))

        self.assertEqual(u'/path/to/r\xe4ksm\xf6rg\xe5s',

                         from_url('file:///path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))

        self.assertEqual(

            u'/path/to/r\xe4ksm\xf6rg\xe5s',

            from_url('file://localhost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))

        self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')

        self.assertRaises(

            urlutils.InvalidURL, from_url,

            'file://remotehost/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s')

    def test_win32_local_path_to_url(self):

        to_url = urlutils._win32_local_path_to_url

        self.assertEqual('file:///C:/path/to/foo',

                         to_url('C:/path/to/foo'))

        # BOGUS: on win32, ntpath.abspath will strip trailing

        #       whitespace, so this will always fail

        #       Though under linux, it fakes abspath support

        #       and thus will succeed

        # self.assertEqual('file:///C:/path/to/foo%20',

        #     to_url('C:/path/to/foo '))

        self.assertEqual('file:///C:/path/to/f%20oo',

                         to_url('C:/path/to/f oo'))

        self.assertEqual('file:///', to_url('/'))

        self.assertEqual('file:///C:/path/to/foo%2Cbar',

                         to_url('C:/path/to/foo,bar'))

        try:

            result = to_url(u'd:/path/to/r\xe4ksm\xf6rg\xe5s')

        except UnicodeError:

            raise TestSkipped("local encoding cannot handle unicode")

        self.assertEqual(

            'file:///D:/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)

        self.assertIsInstance(result, str)

    def test_win32_unc_path_to_url(self):

        self.requireFeature(features.win32_feature)

        to_url = urlutils._win32_local_path_to_url

        self.assertEqual('file://HOST/path',

                         to_url(r'\\HOST\path'))

        self.assertEqual('file://HOST/path',

                         to_url('//HOST/path'))

        try:

            result = to_url(u'//HOST/path/to/r\xe4ksm\xf6rg\xe5s')

        except UnicodeError:

            raise TestSkipped("local encoding cannot handle unicode")

        self.assertEqual(

            'file://HOST/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s', result)

        self.assertFalse(isinstance(result, str))

    def test_win32_local_path_from_url(self):

        from_url = urlutils._win32_local_path_from_url

        self.assertEqual('C:/path/to/foo',

                         from_url('file:///C|/path/to/foo'))

        self.assertEqual(

            u'D:/path/to/r\xe4ksm\xf6rg\xe5s',

            from_url('file:///d|/path/to/r%C3%A4ksm%C3%B6rg%C3%A5s'))

        self.assertEqual(

            u'D:/path/to/r\xe4ksm\xf6rg\xe5s',

            from_url('file:///d:/path/to/r%c3%a4ksm%c3%b6rg%c3%a5s'))

        self.assertEqual('/', from_url('file:///'))

        self.assertEqual('C:/path/to/foo',

                         from_url('file:///C|/path/to/foo,branch=foo'))

        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///C:')

        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///c')

        self.assertRaises(urlutils.InvalidURL, from_url, '/path/to/foo')

        # Not a valid _win32 url, no drive letter

        self.assertRaises(urlutils.InvalidURL, from_url, 'file:///path/to/foo')

    def test_win32_unc_path_from_url(self):

        from_url = urlutils._win32_local_path_from_url

        self.assertEqual('//HOST/path', from_url('file://HOST/path'))

        self.assertEqual('//HOST/path',

                         from_url('file://HOST/path,branch=foo'))

        # despite IE allows 2, 4, 5 and 6 slashes in URL to another machine

        # we want to use only 2 slashes

        # Firefox understand only 5 slashes in URL, but it's ugly

        self.assertRaises(urlutils.InvalidURL, from_url, 'file:////HOST/path')

        self.assertRaises(urlutils.InvalidURL, from_url, 'file://///HOST/path')

        self.assertRaises(urlutils.InvalidURL, from_url,

                          'file://////HOST/path')

        # check for file://C:/ instead of file:///C:/

        self.assertRaises(urlutils.InvalidURL, from_url, 'file://C:/path')

    def test_win32_extract_drive_letter(self):

        extract = urlutils._win32_extract_drive_letter

        self.assertEqual(('file:///C:', '/foo'), extract('file://', '/C:/foo'))

        self.assertEqual(('file:///d|', '/path'),

                         extract('file://', '/d|/path'))

        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/path')

        # Root drives without slash treated as invalid, see bug #841322

        self.assertEqual(('file:///C:', '/'), extract('file://', '/C:/'))

        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:')

        # Invalid without drive separator or following forward slash

        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C')

        self.assertRaises(urlutils.InvalidURL, extract, 'file://', '/C:ool')

    def test_split(self):

        # Test breezy.urlutils.split()

        split = urlutils.split

        if sys.platform == 'win32':

            self.assertRaises(urlutils.InvalidURL, split,

                              'file:///path/to/foo')

            self.assertEqual(('file:///C|/', 'foo'), split('file:///C|/foo'))

            self.assertEqual(('file:///C:/', ''), split('file:///C:/'))

        else:

            self.assertEqual(('file:///', 'foo'), split('file:///foo'))

            self.assertEqual(('file:///', ''), split('file:///'))

        self.assertEqual(('http://host/path/to', 'foo'),

                         split('http://host/path/to/foo'))

        self.assertEqual(('http://host/path/to', 'foo'),

                         split('http://host/path/to/foo/'))

        self.assertEqual(

            ('http://host/path/to/foo', ''),

            split('http://host/path/to/foo/', exclude_trailing_slash=False))

        self.assertEqual(('http://host/', 'path'), split('http://host/path'))

        self.assertEqual(('http://host/', ''), split('http://host/'))

        self.assertEqual(('http://host', ''), split('http://host'))

        self.assertEqual(('http:///nohost', 'path'),

                         split('http:///nohost/path'))

        self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),

                         split('random+scheme://user:pass@ahost:port/path'))

        self.assertEqual(('random+scheme://user:pass@ahost:port/', 'path'),

                         split('random+scheme://user:pass@ahost:port/path/'))

        self.assertEqual(('random+scheme://user:pass@ahost:port/', ''),

                         split('random+scheme://user:pass@ahost:port/'))

        # relative paths

        self.assertEqual(('path/to', 'foo'), split('path/to/foo'))

        self.assertEqual(('path/to', 'foo'), split('path/to/foo/'))

        self.assertEqual(('path/to/foo', ''),

                         split('path/to/foo/', exclude_trailing_slash=False))

        self.assertEqual(('path/..', 'foo'), split('path/../foo'))

        self.assertEqual(('../path', 'foo'), split('../path/foo'))

    def test_strip_segment_parameters(self):

        strip_segment_parameters = urlutils.strip_segment_parameters

        # Check relative references with absolute paths

        self.assertEqual("/some/path",

                         strip_segment_parameters("/some/path"))

        self.assertEqual("/some/path",

                         strip_segment_parameters("/some/path,tip"))

        self.assertEqual("/some,dir/path",

                         strip_segment_parameters("/some,dir/path,tip"))

        self.assertEqual(

            "/somedir/path",

            strip_segment_parameters("/somedir/path,heads%2Ftip"))

        self.assertEqual(

            "/somedir/path",

            strip_segment_parameters("/somedir/path,heads%2Ftip,bar"))

        # Check relative references with relative paths

        self.assertEqual("", strip_segment_parameters(",key1=val1"))

        self.assertEqual("foo/", strip_segment_parameters("foo/,key1=val1"))

        self.assertEqual("foo", strip_segment_parameters("foo,key1=val1"))

        self.assertEqual(

            "foo/base,la=bla/other/elements",

            strip_segment_parameters("foo/base,la=bla/other/elements"))

        self.assertEqual(

            "foo/base,la=bla/other/elements",

            strip_segment_parameters("foo/base,la=bla/other/elements,a=b"))

        # TODO: Check full URLs as well as relative references

    def test_split_segment_parameters_raw(self):

        split_segment_parameters_raw = urlutils.split_segment_parameters_raw

        # Check relative references with absolute paths

        self.assertEqual(("/some/path", []),

                         split_segment_parameters_raw("/some/path"))

        self.assertEqual(("/some/path", ["tip"]),

                         split_segment_parameters_raw("/some/path,tip"))

        self.assertEqual(("/some,dir/path", ["tip"]),

                         split_segment_parameters_raw("/some,dir/path,tip"))

        self.assertEqual(

            ("/somedir/path", ["heads%2Ftip"]),

            split_segment_parameters_raw("/somedir/path,heads%2Ftip"))

        self.assertEqual(

            ("/somedir/path", ["heads%2Ftip", "bar"]),

            split_segment_parameters_raw("/somedir/path,heads%2Ftip,bar"))

        # Check relative references with relative paths

        self.assertEqual(("", ["key1=val1"]),

                         split_segment_parameters_raw(",key1=val1"))

        self.assertEqual(("foo/", ["key1=val1"]),

                         split_segment_parameters_raw("foo/,key1=val1"))

        self.assertEqual(("foo", ["key1=val1"]),

                         split_segment_parameters_raw("foo,key1=val1"))

        self.assertEqual(

            ("foo/base,la=bla/other/elements", []),

            split_segment_parameters_raw("foo/base,la=bla/other/elements"))

        self.assertEqual(

            ("foo/base,la=bla/other/elements", ["a=b"]),

            split_segment_parameters_raw("foo/base,la=bla/other/elements,a=b"))

        # TODO: Check full URLs as well as relative references

    def test_split_segment_parameters(self):

        split_segment_parameters = urlutils.split_segment_parameters

        # Check relative references with absolute paths

        self.assertEqual(("/some/path", {}),

                         split_segment_parameters("/some/path"))

        self.assertEqual(("/some/path", {"branch": "tip"}),

                         split_segment_parameters("/some/path,branch=tip"))