intermediate changes

ref:cde9a383711a11544ce7e107a78147fb96cc4029

1 files changed, 379 insertions, 0 deletions

diff --git a/util/folder/path_ut.pyx b/util/folder/path_ut.pyx
new file mode 100644
index 0000000000..e2537683ee
--- /dev/null
+++ b/util/folder/path_ut.pyx
@@ -0,0 +1,379 @@
+# cython: c_string_type=str, c_string_encoding=utf8
+
+from util.folder.path cimport TFsPath
+from util.generic.string cimport TString, TStringBuf
+from util.generic.vector cimport TVector
+
+import unittest
+import yatest.common
+
+import os.path
+
+
+class TestPath(unittest.TestCase):
+    def test_ctor1(self):
+        cdef TFsPath path = TFsPath()
+        self.assertEqual(path.IsDefined(), False)
+        self.assertEquals(path.c_str(), "")
+
+    def test_ctor2(self):
+        cdef TString str_path = "/a/b/c"
+        cdef TFsPath path = TFsPath(str_path)
+        self.assertEqual(path.IsDefined(), True)
+        self.assertEquals(path.c_str(), "/a/b/c")
+
+    def test_ctor3(self):
+        cdef TStringBuf buf_path = "/a/b/c"
+        cdef TFsPath path = TFsPath(buf_path)
+        self.assertEqual(path.IsDefined(), True)
+        self.assertEquals(path.c_str(), "/a/b/c")
+
+    def test_ctor4(self):
+        cdef char* char_path = "/a/b/c"
+        cdef TFsPath path = TFsPath(char_path)
+        self.assertEqual(path.IsDefined(), True)
+        self.assertEquals(path.c_str(), "/a/b/c")
+
+    def test_assignment(self):
+        cdef TFsPath path1 = TFsPath("/a/b")
+        cdef TFsPath path2 = TFsPath("/a/c")
+
+        self.assertEquals(path1.GetPath(), "/a/b")
+        self.assertEquals(path2.GetPath(), "/a/c")
+
+        path2 = path1
+
+        self.assertEquals(path1.GetPath(), "/a/b")
+        self.assertEquals(path2.GetPath(), "/a/b")
+
+    def test_check_defined(self):
+        cdef TFsPath path1 = TFsPath()
+        with self.assertRaises(RuntimeError):
+            path1.CheckDefined()
+        self.assertEqual(path1.IsDefined(), False)
+        if path1:
+            assert False
+        else:
+            pass
+
+        cdef TFsPath path2 = TFsPath("")
+        with self.assertRaises(RuntimeError):
+            path2.CheckDefined()
+        self.assertEqual(path2.IsDefined(), False)
+        if path2:
+            assert False
+        else:
+            pass
+
+        cdef TFsPath path3 = TFsPath("/")
+        path3.CheckDefined()
+        self.assertEqual(path3.IsDefined(), True)
+        if path3:
+            pass
+        else:
+            assert False
+
+    def test_comparison(self):
+        cdef TFsPath path1 = TFsPath("/a/b")
+        cdef TFsPath path2 = TFsPath("/a/c")
+        cdef TFsPath path3 = TFsPath("/a/b")
+
+        self.assertEqual(path1 == path3, True)
+        self.assertEqual(path1 != path2, True)
+        self.assertEqual(path3 != path2, True)
+
+    def test_concatenation(self):
+        cdef TFsPath path1 = TFsPath("/a")
+        cdef TFsPath path2 = TFsPath("b")
+        cdef TFsPath path3 = path1 / path2
+        cdef TFsPath path4 = TFsPath("/a/b")
+
+        self.assertEqual(path3 == path4, True)
+
+    def test_fix(self):
+        cdef TFsPath path = TFsPath("test_fix/b/c/../d")
+        cdef TFsPath fixed = path.Fix()
+        self.assertEquals(fixed.GetPath(), "test_fix/b/d")
+
+    def test_parts(self):
+        cdef TFsPath path = TFsPath("/a/b/c")
+        self.assertEquals(path.GetPath(), "/a/b/c")
+        self.assertEquals(path.GetName(), "c")
+        self.assertEquals(path.GetExtension(), "")
+        self.assertEquals(path.Basename(), "c")
+        self.assertEquals(path.Dirname(), "/a/b")
+
+        cdef TFsPath path_ext = TFsPath("/a/b/c.ext")
+        self.assertEquals(path_ext.GetPath(), "/a/b/c.ext")
+        self.assertEquals(path_ext.GetName(), "c.ext")
+        self.assertEquals(path_ext.GetExtension(), "ext")
+        self.assertEquals(path_ext.Basename(), "c.ext")
+        self.assertEquals(path_ext.Dirname(), "/a/b")
+
+        cdef TFsPath path_only_ext = TFsPath("/a/b/.ext")
+        self.assertEquals(path_only_ext.GetPath(), "/a/b/.ext")
+        self.assertEquals(path_only_ext.GetName(), ".ext")
+        self.assertEquals(path_only_ext.GetExtension(), "")
+        self.assertEquals(path_only_ext.Basename(), ".ext")
+        self.assertEquals(path_only_ext.Dirname(), "/a/b")
+
+        cdef TFsPath path_dir = TFsPath("/a/b/")
+        self.assertEquals(path_dir.GetPath(), "/a/b/")
+        self.assertEquals(path_dir.GetName(), "b")
+        self.assertEquals(path_dir.GetExtension(), "")
+        self.assertEquals(path_dir.Basename(), "b")
+        self.assertEquals(path_dir.Dirname(), "/a")
+
+    def test_absolute(self):
+        cdef TFsPath path_absolute = TFsPath("/a/b/c")
+        self.assertEquals(path_absolute.IsAbsolute(), True)
+        self.assertEquals(path_absolute.IsRelative(), False)
+
+        self.assertEquals(path_absolute.IsSubpathOf(TFsPath("/a/b")), True)
+        self.assertEquals(path_absolute.IsNonStrictSubpathOf(TFsPath("/a/b")), True)
+        self.assertEquals(TFsPath("/a/b").IsContainerOf(path_absolute), True)
+
+        self.assertEquals(path_absolute.IsSubpathOf(TFsPath("/a/b/c")), False)
+        self.assertEquals(path_absolute.IsNonStrictSubpathOf(TFsPath("/a/b/c")), True)
+        self.assertEquals(TFsPath("/a/b/c").IsContainerOf(path_absolute), False)
+
+        self.assertEquals(path_absolute.IsSubpathOf(TFsPath("/a/c")), False)
+        self.assertEquals(path_absolute.IsNonStrictSubpathOf(TFsPath("/a/c")), False)
+        self.assertEquals(TFsPath("/a/c").IsContainerOf(path_absolute), False)
+
+        with self.assertRaises(RuntimeError):
+            path_absolute.RelativeTo(TFsPath("/a/c"))
+        self.assertEquals(path_absolute.RelativePath(TFsPath("/a/с")).GetPath(), "../b/c")
+        self.assertEquals(path_absolute.RelativeTo(TFsPath("/a")).GetPath(), "b/c")
+        self.assertEquals(path_absolute.RelativePath(TFsPath("/a")).GetPath(), "b/c")
+        self.assertEquals(path_absolute.RelativeTo(TFsPath("/")).GetPath(), "a/b/c")
+        self.assertEquals(path_absolute.RelativePath(TFsPath("/")).GetPath(), "a/b/c")
+
+        with self.assertRaises(RuntimeError):
+            path_absolute.RelativeTo(TFsPath("./a"))
+        with self.assertRaises(RuntimeError):
+            path_absolute.RelativePath(TFsPath("d"))
+        self.assertEquals(path_absolute.RelativePath(TFsPath("./a")).GetPath(), "b/c")
+
+        self.assertEquals(path_absolute.Parent().GetPath(), "/a/b")
+        self.assertEquals(path_absolute.Child("d").GetPath(), "/a/b/c/d")
+
+    def test_relative(self):
+        cdef TFsPath path_relative_1 = TFsPath("a/b/c")
+        self.assertEquals(path_relative_1.IsAbsolute(), False)
+        self.assertEquals(path_relative_1.IsRelative(), True)
+
+        self.assertEquals(path_relative_1.IsSubpathOf(TFsPath("a/b")), True)
+        self.assertEquals(path_relative_1.IsNonStrictSubpathOf(TFsPath("a/b")), True)
+        self.assertEquals(TFsPath("a/b").IsContainerOf(path_relative_1), True)
+
+        self.assertEquals(path_relative_1.IsSubpathOf(TFsPath("a/b/c")), False)
+        self.assertEquals(path_relative_1.IsNonStrictSubpathOf(TFsPath("a/b/c")), True)
+        self.assertEquals(TFsPath("a/b/c").IsContainerOf(path_relative_1), False)
+
+        self.assertEquals(path_relative_1.IsSubpathOf(TFsPath("a/c")), False)
+        self.assertEquals(path_relative_1.IsNonStrictSubpathOf(TFsPath("a/c")), False)
+        self.assertEquals(TFsPath("a/c").IsContainerOf(path_relative_1), False)
+
+        self.assertEquals(path_relative_1.Parent().GetPath(), "a/b")
+        self.assertEquals(path_relative_1.Child("d").GetPath(), "a/b/c/d")
+
+        cdef TFsPath path_relative_2 = TFsPath("./a/b/c")
+        self.assertEquals(path_relative_2.IsAbsolute(), False)
+        self.assertEquals(path_relative_2.IsRelative(), True)
+
+        self.assertEquals(path_relative_2.IsSubpathOf(TFsPath("a/b")), True)
+        self.assertEquals(path_relative_2.IsNonStrictSubpathOf(TFsPath("a/b")), True)
+        self.assertEquals(TFsPath("a/b").IsContainerOf(path_relative_2), True)
+
+        self.assertEquals(path_relative_2.IsSubpathOf(TFsPath("a/b/c")), False)
+        self.assertEquals(path_relative_2.IsNonStrictSubpathOf(TFsPath("a/b/c")), True)
+        self.assertEquals(TFsPath("a/b/c").IsContainerOf(path_relative_2), False)
+
+        self.assertEquals(path_relative_2.IsSubpathOf(TFsPath("a/c")), False)
+        self.assertEquals(path_relative_2.IsNonStrictSubpathOf(TFsPath("a/c")), False)
+        self.assertEquals(TFsPath("a/c").IsContainerOf(path_relative_2), False)
+
+        with self.assertRaises(RuntimeError):
+            path_relative_2.RelativeTo(TFsPath("a/c"))
+        self.assertEquals(path_relative_2.RelativePath(TFsPath("a/с")).GetPath(), "../b/c")
+        self.assertEquals(path_relative_2.RelativeTo(TFsPath("a")).GetPath(), "b/c")
+        self.assertEquals(path_relative_2.RelativePath(TFsPath("a")).GetPath(), "b/c")
+        self.assertEquals(path_relative_2.RelativeTo(TFsPath("./")).GetPath(), "a/b/c")
+        self.assertEquals(path_relative_2.RelativePath(TFsPath("/a")).GetPath(), "b/c")
+
+        with self.assertRaises(RuntimeError):
+            self.assertEquals(path_relative_2.RelativePath(TFsPath("./")).GetPath(), "a/b/c")
+
+        with self.assertRaises(RuntimeError):
+            path_relative_2.RelativeTo(TFsPath("/d"))
+        with self.assertRaises(RuntimeError):
+            path_relative_2.RelativePath(TFsPath("/d"))
+        with self.assertRaises(RuntimeError):
+            path_relative_2.RelativePath(TFsPath("/"))
+
+        self.assertEquals(path_relative_2.Parent().GetPath(), "a/b")
+        self.assertEquals(path_relative_2.Child("d").GetPath(), "a/b/c/d")
+
+    def test_mkdir(self):
+        cdef TFsPath directory = TFsPath("test_mkdir")
+        cdef TFsPath full = directory / directory
+        cdef TFsPath internal = full / directory
+        with self.assertRaises(RuntimeError):
+            full.MkDir()
+        full.MkDirs()
+        internal.MkDir()
+
+    def test_list(self):
+        cdef TFsPath dir = TFsPath("test_list")
+        dir.MkDir()
+        TFsPath("test_list/b").Touch()
+        TFsPath("test_list/c").Touch()
+
+        cdef TVector[TFsPath] files
+        cdef TVector[TString] names
+
+        dir.List(files)
+        dir.ListNames(names)
+
+        self.assertEquals(files.size(), 2)
+        self.assertEquals(sorted([files[0].GetPath(), files[1].GetPath()]), ["test_list/b", "test_list/c"])
+        self.assertEquals(names.size(), 2)
+        self.assertEquals(sorted(list(names)), ["b", "c"])
+
+    def test_contains(self):
+        cdef TFsPath path = TFsPath("a/b/c")
+        self.assertEquals(path.Contains("c"), True)
+        self.assertEquals(path.Contains("b"), True)
+        self.assertEquals(path.Contains("d"), False)
+
+    def test_delete(self):
+        cdef TFsPath root = TFsPath("/")
+        with self.assertRaises(RuntimeError):
+            root.DeleteIfExists()
+        with self.assertRaises(RuntimeError):
+            root.ForceDelete()
+
+        cdef TFsPath directory = TFsPath("test_delete")
+        cdef TFsPath full = directory / directory
+        full.MkDirs()
+
+        self.assertEquals(full.Exists(), True)
+        with self.assertRaises(RuntimeError):
+            directory.DeleteIfExists()
+        self.assertEquals(directory.Exists(), True)
+        directory.ForceDelete()
+        self.assertEquals(directory.Exists(), False)
+
+        cdef TFsPath local_file = TFsPath("test_delete_1")
+        self.assertEquals(local_file.Exists(), False)
+        local_file.DeleteIfExists()
+        self.assertEquals(local_file.Exists(), False)
+        local_file.ForceDelete()
+        self.assertEquals(local_file.Exists(), False)
+
+        local_file.Touch()
+        self.assertEquals(local_file.Exists(), True)
+        local_file.DeleteIfExists()
+        self.assertEquals(local_file.Exists(), False)
+
+        local_file.Touch()
+        self.assertEquals(local_file.Exists(), True)
+        local_file.ForceDelete()
+        self.assertEquals(local_file.Exists(), False)
+
+        full.MkDirs()
+        self.assertEquals(full.Exists(), True)
+        full.DeleteIfExists()
+        self.assertEquals(full.Exists(), False)
+        self.assertEquals(directory.Exists(), True)
+        directory.DeleteIfExists()
+        self.assertEquals(directory.Exists(), False)
+
+    def test_checks(self):
+        cdef TFsPath local_file = TFsPath("test_checks")
+        with self.assertRaises(RuntimeError):
+            local_file.CheckExists()
+        local_file.Touch()
+        self.assertEquals(local_file.Exists(), True)
+        self.assertEquals(local_file.IsDirectory(), False)
+        self.assertEquals(local_file.IsFile(), True)
+        self.assertEquals(local_file.IsSymlink(), False)
+        local_file.CheckExists()
+
+        local_file.DeleteIfExists()
+        local_file.MkDir()
+        self.assertEquals(local_file.Exists(), True)
+        self.assertEquals(local_file.IsDirectory(), True)
+        self.assertEquals(local_file.IsFile(), False)
+        self.assertEquals(local_file.IsSymlink(), False)
+        local_file.CheckExists()
+
+    def test_rename(self):
+        cdef TFsPath path = TFsPath("test_rename_a")
+        path.Touch()
+
+        cdef TString path_str = "test_rename_b"
+        cdef TFsPath path_from_str = TFsPath(path_str)
+        self.assertEquals(path.Exists(), True)
+        self.assertEquals(path_from_str.Exists(), False)
+        path.RenameTo(path_str)
+        self.assertEquals(path.Exists(), False)
+        self.assertEquals(path_from_str.Exists(), True)
+
+        cdef const char* path_char = "test_rename_c"
+        cdef TFsPath path_from_char = TFsPath(path_char)
+        self.assertEquals(path_from_str.Exists(), True)
+        self.assertEquals(path_from_char.Exists(), False)
+        path_from_str.RenameTo(path_char)
+        self.assertEquals(path_from_str.Exists(), False)
+        self.assertEquals(path_from_char.Exists(), True)
+
+        path_from_char.RenameTo(path)
+
+        self.assertEquals(path_from_char.Exists(), False)
+        self.assertEquals(path.Exists(), True)
+
+        path.ForceRenameTo(path_str)
+
+        self.assertEquals(path_from_str.Exists(), True)
+        self.assertEquals(path.Exists(), False)
+
+        with self.assertRaises(RuntimeError):
+            path_from_str.RenameTo("")
+
+    def test_copy(self):
+        cdef TString dst = "test_copy_dst"
+        cdef TFsPath src_path = TFsPath("test_copy_src")
+        cdef TFsPath dst_path = TFsPath(dst)
+        self.assertEquals(src_path.Exists(), False)
+        src_path.Touch()
+        self.assertEquals(src_path.Exists(), True)
+        src_path.CopyTo(dst, False)
+        self.assertEquals(src_path.Exists(), True)
+        self.assertEquals(dst_path.Exists(), True)
+
+    def test_real_path(self):
+        cdef TFsPath path = TFsPath("test_real_path_a")
+        path.Touch()
+        self.assertEquals(path.RealPath().GetPath(), os.path.join(yatest.common.work_path(), "test_real_path_a"))
+        self.assertEquals(path.RealLocation().GetPath(), os.path.join(yatest.common.work_path(), "test_real_path_a"))
+        with self.assertRaises(RuntimeError):
+            path.ReadLink()
+
+    def test_cwd(self):
+        cdef TFsPath path = TFsPath.Cwd()
+        self.assertEquals(path.GetPath(), yatest.common.work_path())
+
+    def test_swap(self):
+        cdef TFsPath first = TFsPath("first")
+        cdef TFsPath second = TFsPath("second")
+
+        self.assertEquals(first.GetPath(), "first")
+        self.assertEquals(second.GetPath(), "second")
+        first.Swap(second)
+        self.assertEquals(first.GetPath(), "second")
+        self.assertEquals(second.GetPath(), "first")
+        second.Swap(first)
+        self.assertEquals(first.GetPath(), "first")
+        self.assertEquals(second.GetPath(), "second")