def test_pathto_w_slash(self):
before = Path('/a/b/')
after = Path('/a/b/c')
self.assertEqual(before.get_pathto(after), 'c')
before = Path('u/a/\u03A0/')
after = Path('u/a/\u03A0/c')
self.assertEqual(before.get_pathto(after), u'c')
class PathComparisonTestCase(unittest.TestCase):
def setUp(self):
self.path_wo_slash = Path('/a/b/c')
self.path_w_slash = Path('/a/b/c/')
self.wo_to_w = self.path_wo_slash.get_pathto(self.path_w_slash)
self.conversion = str
#########################################################################
# Comparing Path objects
def test_with_eq_without_trailing_slash(self):
"""A path is not the same with a trailing slash."""
self.assertNotEqual(self.path_wo_slash, self.path_w_slash)
def test_wo_to_w_eq_path_dot(self):
"""The path to the same with a trailing slash returns Path('.')."""
self.assertEqual(self.wo_to_w, Path('.'))
#########################################################################
# Comparing with string conversions.
def test_path_wo_slash_eq_string(self):
"""A path without trailing slash equals its string conversion."""
self.assertEqual(self.path_wo_slash,
self.conversion(self.path_wo_slash))
def test_path_w_slash_eq_string(self):
"""A path with trailing slash equals its string conversion."""
self.assertEqual(self.path_w_slash, self.conversion(self.path_w_slash))
def test_path_to_similar_eq_string_dot(self):
"""The path to the same with a trailing slash equals '.'."""
self.assertEqual(self.wo_to_w, '.')
def test_absolute(self):
self.assert_(self.path_w_slash.is_absolute())
self.assert_(self.path_wo_slash.is_absolute())
def test1(self):
a = Path('/a/b/c')
b = Path('/a/b/d/e')
self.assertEqual(a.get_prefix(b), '/a/b')
a = Path(u'/a/\u03A0/c')
b = Path(u'/a/\u03A0/d/e')
self.assertEqual(a.get_prefix(b), u'/a/\u03A0')
def test_resolve2_w_slash(self):
before = Path('/a/b/')
after = Path('/a/b/c')
self.assertEqual(before.resolve2('c'), after)
before = Path(u'/a/b/')
after = Path(u'/a/b/\u03A0')
self.assertEqual(before.resolve2(u'\u03A0'), after)
def test_resolve_wo_slash(self):
before = Path('/a/b')
after = Path('/a/c')
self.assertEqual(before.resolve('c'), after)
before = Path(u'/a/b')
after = Path(u'/a/\u03A0')
self.assertEqual(before.resolve(u'\u03A0'), after)
def test_absnorm(self):
"""
Test the normalization '/..' = '/'
"""
path = Path('/../../a/b/c')
self.assertEqual(str(path), '/a/b/c')
self.assert_(path.is_absolute())
path = Path(u'/../../a/b/c')
self.assertEqual(unicode(path), u'/a/b/c')
self.assert_(path.is_absolute())
def test_backnorm(self):
"""
Test the normalization 'a/../b' = 'b'
"""
path = Path('a/b/c/../d')
self.assertEqual(str(path), 'a/b/d')
self.assert_(path.is_relative())
path = Path(u'a/b/c/../d')
self.assertEqual(unicode(path), u'a/b/d')
self.assert_(path.is_relative())
def test_relnorm(self):
"""
Check that '../' = '../'
"""
path = Path('../../a//.//b/c')
self.assertEqual(str(path), '../../a/b/c')
self.assert_(path.is_relative())
path = Path(u'../../a//.//b\u03A0\u03A3\u03A9/c')
self.assertEqual(path, u'../../a/b\u03A0\u03A3\u03A9/c')
self.assert_(path.is_relative())
def test_resolve2_w_slash(self):
before = Path('/a/b/')
after = Path('/a/b/c')
self.assertEqual(before.resolve2('c'), after)
before = Path(u'/a/b/')
after = Path(u'/a/b/\u03A0')
self.assertEqual(before.resolve2(u'\u03A0'), after)
def test1(self):
a = Path('/a/b/c')
b = Path('/a/b/d/e')
self.assertEqual(a.get_prefix(b), '/a/b')
a = Path(u'/a/\u03A0/c')
b = Path(u'/a/\u03A0/d/e')
self.assertEqual(a.get_prefix(b), u'/a/\u03A0')
def test_pathto_w_slash(self):
before = Path('/a/b/')
after = Path('/a/b/c')
self.assertEqual(before.get_pathto(after), 'c')
before = Path('u/a/\u03A0/')
after = Path('u/a/\u03A0/c')
self.assertEqual(before.get_pathto(after), u'c')
def test_resolve_wo_slash(self):
before = Path('/a/b')
after = Path('/a/c')
self.assertEqual(before.resolve('c'), after)
before = Path(u'/a/b')
after = Path(u'/a/\u03A0')
self.assertEqual(before.resolve(u'\u03A0'), after)
def test_simplenorm(self):
"""
Test the simple path normalization:
- 'a/./b' = 'a/b'
- 'a//b' = 'a/b'
- './a' = 'a'
- 'a/' = 'a'
"""
path = Path('./a/./b//c/')
self.assertEqual(str(path), 'a/b/c/')
self.assert_(path.is_relative())
path = Path(u'./a/./b//c/')
self.assertEqual(unicode(path), u'a/b/c/')
self.assert_(path.is_relative())
class UnicodePathComparisonTestCase(PathComparisonTestCase):
def setUp(self):
self.path_wo_slash = Path(u'/a/\u03A0/c')
self.path_w_slash = Path(u'/a/\u03A0/c/')
self.wo_to_w = self.path_wo_slash.get_pathto(self.path_w_slash)
self.conversion = unicode
def test_windows_absolute(self):
# Note that there is no such thing as a windows relative path when a
# drive letter is also specified.
path = Path(u'c:/a/b/c')
self.assert_(path.is_absolute())
self.assert_(not path.is_relative())
path = Path(u'c:a/b/c')
self.assert_(path.is_absolute())
self.assert_(not path.is_relative())
class PathComparisonTestCase(unittest.TestCase):
def setUp(self):
self.path_wo_slash = Path('/a/b/c')
self.path_w_slash = Path('/a/b/c/')
self.wo_to_w = self.path_wo_slash.get_pathto(self.path_w_slash)
self.conversion = str
#########################################################################
# Comparing Path objects
def test_with_eq_without_trailing_slash(self):
"""A path is not the same with a trailing slash."""
self.assertNotEqual(self.path_wo_slash, self.path_w_slash)
def test_wo_to_w_eq_path_dot(self):
"""The path to the same with a trailing slash returns Path('.')."""
self.assertEqual(self.wo_to_w, Path('.'))
#########################################################################
# Comparing with string conversions.
def test_path_wo_slash_eq_string(self):
"""A path without trailing slash equals its string conversion."""
self.assertEqual(self.path_wo_slash, self.conversion(self.path_wo_slash))
def test_path_w_slash_eq_string(self):
"""A path with trailing slash equals its string conversion."""
self.assertEqual(self.path_w_slash, self.conversion(self.path_w_slash))
def test_path_to_similar_eq_string_dot(self):
"""The path to the same with a trailing slash equals '.'."""
self.assertEqual(self.wo_to_w, '.')
def test_absolute(self):
self.assert_(self.path_w_slash.is_absolute())
self.assert_(self.path_wo_slash.is_absolute())
def test_windows_absolute(self):
# Note that there is no such thing as a windows relative path when a
# drive letter is also specified.
path = Path(u'c:/a/b/c')
self.assert_(path.is_absolute())
self.assert_(not path.is_relative())
path = Path(u'c:a/b/c')
self.assert_(path.is_absolute())
self.assert_(not path.is_relative())
def test_absnorm(self):
"""
Test the normalization '/..' = '/'
"""
path = Path('/../../a/b/c')
self.assertEqual(str(path), '/a/b/c')
self.assert_(path.is_absolute())
path = Path(u'/../../a/b/c')
self.assertEqual(unicode(path), u'/a/b/c')
self.assert_(path.is_absolute())
def test_backnorm(self):
"""
Test the normalization 'a/../b' = 'b'
"""
path = Path('a/b/c/../d')
self.assertEqual(str(path), 'a/b/d')
self.assert_(path.is_relative())
path = Path(u'a/b/c/../d')
self.assertEqual(unicode(path), u'a/b/d')
self.assert_(path.is_relative())
def test_relnorm(self):
"""
Check that '../' = '../'
"""
path = Path('../../a//.//b/c')
self.assertEqual(str(path), '../../a/b/c')
self.assert_(path.is_relative())
path = Path(u'../../a//.//b\u03A0\u03A3\u03A9/c')
self.assertEqual(path, u'../../a/b\u03A0\u03A3\u03A9/c')
self.assert_(path.is_relative())
def test_simplenorm(self):
"""
Test the simple path normalization:
- 'a/./b' = 'a/b'
- 'a//b' = 'a/b'
- './a' = 'a'
- 'a/' = 'a'
"""
path = Path('./a/./b//c/')
self.assertEqual(str(path), 'a/b/c/')
self.assert_(path.is_relative())
path = Path(u'./a/./b//c/')
self.assertEqual(unicode(path), u'a/b/c/')
self.assert_(path.is_relative())
class UnicodePathComparisonTestCase(PathComparisonTestCase):
def setUp(self):
self.path_wo_slash = Path(u'/a/\u03A0/c')
self.path_w_slash = Path(u'/a/\u03A0/c/')
self.wo_to_w = self.path_wo_slash.get_pathto(self.path_w_slash)
self.conversion = unicode
def setUp(self):
self.path_wo_slash = Path('/a/b/c')
self.path_w_slash = Path('/a/b/c/')
self.wo_to_w = self.path_wo_slash.get_pathto(self.path_w_slash)
self.conversion = str
def test3(self):
a = Path('/a/b')
self.assertEqual(a.get_pathtoroot(), '../')
a = Path(u'/a/b')
self.assertEqual(a.get_pathtoroot(), u'../')
def test5(self):
a = Path('/a/very/long/path')
self.assertEqual(a.get_pathtoroot(), '../../../')
a = Path(u'/a/very/long/path')
self.assertEqual(a.get_pathtoroot(), u'../../../')
def test7(self):
a = Path('a/b/')
self.assertEqual(a.get_pathtoroot(), '../')
a = Path(u'a/b/')
self.assertEqual(a.get_pathtoroot(), u'../')
def setUp(self):
self.path_wo_slash = Path(u'/a/\u03A0/c')
self.path_w_slash = Path(u'/a/\u03A0/c/')
self.wo_to_w = self.path_wo_slash.get_pathto(self.path_w_slash)
self.conversion = unicode
def setUp(self):
self.path_wo_slash = Path('/a/b/c')
self.path_w_slash = Path('/a/b/c/')
self.wo_to_w = self.path_wo_slash.get_pathto(self.path_w_slash)
self.conversion = str
def test2(self):
a = Path('/a/')
self.assertEqual(a.get_pathtoroot(), '')
a = Path(u'/a/')
self.assertEqual(a.get_pathtoroot(), u'')
def test_relative(self):
path = Path(u'a/b/c')
self.assert_(not path.is_absolute())
self.assert_(path.is_relative())
def test3(self):
a = Path('/a/b')
self.assertEqual(a.get_pathtoroot(), '../')
a = Path(u'/a/b')
self.assertEqual(a.get_pathtoroot(), u'../')
def test2(self):
a = Path('/a/')
self.assertEqual(a.get_pathtoroot(), '')
a = Path(u'/a/')
self.assertEqual(a.get_pathtoroot(), u'')
def test5(self):
a = Path('/a/very/long/path')
self.assertEqual(a.get_pathtoroot(), '../../../')
a = Path(u'/a/very/long/path')
self.assertEqual(a.get_pathtoroot(), u'../../../')
def test_wo_to_w_eq_path_dot(self):
"""The path to the same with a trailing slash returns Path('.')."""
self.assertEqual(self.wo_to_w, Path('.'))
def test7(self):
a = Path('a/b/')
self.assertEqual(a.get_pathtoroot(), '../')
a = Path(u'a/b/')
self.assertEqual(a.get_pathtoroot(), u'../')
def setUp(self):
self.path_wo_slash = Path(u'/a/\u03A0/c')
self.path_w_slash = Path(u'/a/\u03A0/c/')
self.wo_to_w = self.path_wo_slash.get_pathto(self.path_w_slash)
self.conversion = unicode
def test_relative(self):
path = Path(u'a/b/c')
self.assert_(not path.is_absolute())
self.assert_(path.is_relative())