home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 July / maximum-cd-2011-07.iso / DiscContents / LibO_3.3.2_Win_x86_install_multi.exe / libreoffice1.cab / test_posixpath.py < prev    next >
Encoding:
Python Source  |  2011-03-15  |  19.3 KB  |  513 lines
  1. import unittest
  2. from test import test_support
  3.  
  4. import posixpath, os
  5. from posixpath import realpath, abspath, join, dirname, basename, relpath
  6.  
  7. # An absolute path to a temporary filename for testing. We can't rely on TESTFN
  8. # being an absolute path, so we need this.
  9.  
  10. ABSTFN = abspath(test_support.TESTFN)
  11.  
  12. def safe_rmdir(dirname):
  13.     try:
  14.         os.rmdir(dirname)
  15.     except OSError:
  16.         pass
  17.  
  18. class PosixPathTest(unittest.TestCase):
  19.  
  20.     def setUp(self):
  21.         self.tearDown()
  22.  
  23.     def tearDown(self):
  24.         for suffix in ["", "1", "2"]:
  25.             test_support.unlink(test_support.TESTFN + suffix)
  26.             safe_rmdir(test_support.TESTFN + suffix)
  27.  
  28.     def assertIs(self, a, b):
  29.         self.assert_(a is b)
  30.  
  31.     def test_normcase(self):
  32.         # Check that normcase() is idempotent
  33.         p = "FoO/./BaR"
  34.         p = posixpath.normcase(p)
  35.         self.assertEqual(p, posixpath.normcase(p))
  36.  
  37.         self.assertRaises(TypeError, posixpath.normcase)
  38.  
  39.     def test_join(self):
  40.         self.assertEqual(posixpath.join("/foo", "bar", "/bar", "baz"), "/bar/baz")
  41.         self.assertEqual(posixpath.join("/foo", "bar", "baz"), "/foo/bar/baz")
  42.         self.assertEqual(posixpath.join("/foo/", "bar/", "baz/"), "/foo/bar/baz/")
  43.  
  44.         self.assertRaises(TypeError, posixpath.join)
  45.  
  46.     def test_splitdrive(self):
  47.         self.assertEqual(posixpath.splitdrive("/foo/bar"), ("", "/foo/bar"))
  48.  
  49.         self.assertRaises(TypeError, posixpath.splitdrive)
  50.  
  51.     def test_split(self):
  52.         self.assertEqual(posixpath.split("/foo/bar"), ("/foo", "bar"))
  53.         self.assertEqual(posixpath.split("/"), ("/", ""))
  54.         self.assertEqual(posixpath.split("foo"), ("", "foo"))
  55.         self.assertEqual(posixpath.split("////foo"), ("////", "foo"))
  56.         self.assertEqual(posixpath.split("//foo//bar"), ("//foo", "bar"))
  57.  
  58.         self.assertRaises(TypeError, posixpath.split)
  59.  
  60.     def splitextTest(self, path, filename, ext):
  61.         self.assertEqual(posixpath.splitext(path), (filename, ext))
  62.         self.assertEqual(posixpath.splitext("/" + path), ("/" + filename, ext))
  63.         self.assertEqual(posixpath.splitext("abc/" + path), ("abc/" + filename, ext))
  64.         self.assertEqual(posixpath.splitext("abc.def/" + path), ("abc.def/" + filename, ext))
  65.         self.assertEqual(posixpath.splitext("/abc.def/" + path), ("/abc.def/" + filename, ext))
  66.         self.assertEqual(posixpath.splitext(path + "/"), (filename + ext + "/", ""))
  67.  
  68.     def test_splitext(self):
  69.         self.splitextTest("foo.bar", "foo", ".bar")
  70.         self.splitextTest("foo.boo.bar", "foo.boo", ".bar")
  71.         self.splitextTest("foo.boo.biff.bar", "foo.boo.biff", ".bar")
  72.         self.splitextTest(".csh.rc", ".csh", ".rc")
  73.         self.splitextTest("nodots", "nodots", "")
  74.         self.splitextTest(".cshrc", ".cshrc", "")
  75.         self.splitextTest("...manydots", "...manydots", "")
  76.         self.splitextTest("...manydots.ext", "...manydots", ".ext")
  77.         self.splitextTest(".", ".", "")
  78.         self.splitextTest("..", "..", "")
  79.         self.splitextTest("........", "........", "")
  80.         self.splitextTest("", "", "")
  81.         self.assertRaises(TypeError, posixpath.splitext)
  82.  
  83.     def test_isabs(self):
  84.         self.assertIs(posixpath.isabs(""), False)
  85.         self.assertIs(posixpath.isabs("/"), True)
  86.         self.assertIs(posixpath.isabs("/foo"), True)
  87.         self.assertIs(posixpath.isabs("/foo/bar"), True)
  88.         self.assertIs(posixpath.isabs("foo/bar"), False)
  89.  
  90.         self.assertRaises(TypeError, posixpath.isabs)
  91.  
  92.     def test_splitdrive(self):
  93.         self.assertEqual(posixpath.splitdrive("/foo/bar"), ("", "/foo/bar"))
  94.  
  95.         self.assertRaises(TypeError, posixpath.splitdrive)
  96.  
  97.     def test_basename(self):
  98.         self.assertEqual(posixpath.basename("/foo/bar"), "bar")
  99.         self.assertEqual(posixpath.basename("/"), "")
  100.         self.assertEqual(posixpath.basename("foo"), "foo")
  101.         self.assertEqual(posixpath.basename("////foo"), "foo")
  102.         self.assertEqual(posixpath.basename("//foo//bar"), "bar")
  103.  
  104.         self.assertRaises(TypeError, posixpath.basename)
  105.  
  106.     def test_dirname(self):
  107.         self.assertEqual(posixpath.dirname("/foo/bar"), "/foo")
  108.         self.assertEqual(posixpath.dirname("/"), "/")
  109.         self.assertEqual(posixpath.dirname("foo"), "")
  110.         self.assertEqual(posixpath.dirname("////foo"), "////")
  111.         self.assertEqual(posixpath.dirname("//foo//bar"), "//foo")
  112.  
  113.         self.assertRaises(TypeError, posixpath.dirname)
  114.  
  115.     def test_commonprefix(self):
  116.         self.assertEqual(
  117.             posixpath.commonprefix([]),
  118.             ""
  119.         )
  120.         self.assertEqual(
  121.             posixpath.commonprefix(["/home/swenson/spam", "/home/swen/spam"]),
  122.             "/home/swen"
  123.         )
  124.         self.assertEqual(
  125.             posixpath.commonprefix(["/home/swen/spam", "/home/swen/eggs"]),
  126.             "/home/swen/"
  127.         )
  128.         self.assertEqual(
  129.             posixpath.commonprefix(["/home/swen/spam", "/home/swen/spam"]),
  130.             "/home/swen/spam"
  131.         )
  132.  
  133.         testlist = ['', 'abc', 'Xbcd', 'Xb', 'XY', 'abcd', 'aXc', 'abd', 'ab', 'aX', 'abcX']
  134.         for s1 in testlist:
  135.             for s2 in testlist:
  136.                 p = posixpath.commonprefix([s1, s2])
  137.                 self.assert_(s1.startswith(p))
  138.                 self.assert_(s2.startswith(p))
  139.                 if s1 != s2:
  140.                     n = len(p)
  141.                     self.assertNotEqual(s1[n:n+1], s2[n:n+1])
  142.  
  143.     def test_getsize(self):
  144.         f = open(test_support.TESTFN, "wb")
  145.         try:
  146.             f.write("foo")
  147.             f.close()
  148.             self.assertEqual(posixpath.getsize(test_support.TESTFN), 3)
  149.         finally:
  150.             if not f.closed:
  151.                 f.close()
  152.  
  153.     def test_time(self):
  154.         f = open(test_support.TESTFN, "wb")
  155.         try:
  156.             f.write("foo")
  157.             f.close()
  158.             f = open(test_support.TESTFN, "ab")
  159.             f.write("bar")
  160.             f.close()
  161.             f = open(test_support.TESTFN, "rb")
  162.             d = f.read()
  163.             f.close()
  164.             self.assertEqual(d, "foobar")
  165.  
  166.             self.assert_(
  167.                 posixpath.getctime(test_support.TESTFN) <=
  168.                 posixpath.getmtime(test_support.TESTFN)
  169.             )
  170.         finally:
  171.             if not f.closed:
  172.                 f.close()
  173.  
  174.     def test_islink(self):
  175.         self.assertIs(posixpath.islink(test_support.TESTFN + "1"), False)
  176.         f = open(test_support.TESTFN + "1", "wb")
  177.         try:
  178.             f.write("foo")
  179.             f.close()
  180.             self.assertIs(posixpath.islink(test_support.TESTFN + "1"), False)
  181.             if hasattr(os, "symlink"):
  182.                 os.symlink(test_support.TESTFN + "1", test_support.TESTFN + "2")
  183.                 self.assertIs(posixpath.islink(test_support.TESTFN + "2"), True)
  184.                 os.remove(test_support.TESTFN + "1")
  185.                 self.assertIs(posixpath.islink(test_support.TESTFN + "2"), True)
  186.                 self.assertIs(posixpath.exists(test_support.TESTFN + "2"), False)
  187.                 self.assertIs(posixpath.lexists(test_support.TESTFN + "2"), True)
  188.         finally:
  189.             if not f.close():
  190.                 f.close()
  191.  
  192.         self.assertRaises(TypeError, posixpath.islink)
  193.  
  194.     def test_exists(self):
  195.         self.assertIs(posixpath.exists(test_support.TESTFN), False)
  196.         f = open(test_support.TESTFN, "wb")
  197.         try:
  198.             f.write("foo")
  199.             f.close()
  200.             self.assertIs(posixpath.exists(test_support.TESTFN), True)
  201.             self.assertIs(posixpath.lexists(test_support.TESTFN), True)
  202.         finally:
  203.             if not f.close():
  204.                 f.close()
  205.  
  206.         self.assertRaises(TypeError, posixpath.exists)
  207.  
  208.     def test_isdir(self):
  209.         self.assertIs(posixpath.isdir(test_support.TESTFN), False)
  210.         f = open(test_support.TESTFN, "wb")
  211.         try:
  212.             f.write("foo")
  213.             f.close()
  214.             self.assertIs(posixpath.isdir(test_support.TESTFN), False)
  215.             os.remove(test_support.TESTFN)
  216.             os.mkdir(test_support.TESTFN)
  217.             self.assertIs(posixpath.isdir(test_support.TESTFN), True)
  218.             os.rmdir(test_support.TESTFN)
  219.         finally:
  220.             if not f.close():
  221.                 f.close()
  222.  
  223.         self.assertRaises(TypeError, posixpath.isdir)
  224.  
  225.     def test_isfile(self):
  226.         self.assertIs(posixpath.isfile(test_support.TESTFN), False)
  227.         f = open(test_support.TESTFN, "wb")
  228.         try:
  229.             f.write("foo")
  230.             f.close()
  231.             self.assertIs(posixpath.isfile(test_support.TESTFN), True)
  232.             os.remove(test_support.TESTFN)
  233.             os.mkdir(test_support.TESTFN)
  234.             self.assertIs(posixpath.isfile(test_support.TESTFN), False)
  235.             os.rmdir(test_support.TESTFN)
  236.         finally:
  237.             if not f.close():
  238.                 f.close()
  239.  
  240.         self.assertRaises(TypeError, posixpath.isdir)
  241.  
  242.     def test_samefile(self):
  243.         f = open(test_support.TESTFN + "1", "wb")
  244.         try:
  245.             f.write("foo")
  246.             f.close()
  247.             self.assertIs(
  248.                 posixpath.samefile(
  249.                     test_support.TESTFN + "1",
  250.                     test_support.TESTFN + "1"
  251.                 ),
  252.                 True
  253.             )
  254.             # If we don't have links, assume that os.stat doesn't return resonable
  255.             # inode information and thus, that samefile() doesn't work
  256.             if hasattr(os, "symlink"):
  257.                 os.symlink(
  258.                     test_support.TESTFN + "1",
  259.                     test_support.TESTFN + "2"
  260.                 )
  261.                 self.assertIs(
  262.                     posixpath.samefile(
  263.                         test_support.TESTFN + "1",
  264.                         test_support.TESTFN + "2"
  265.                     ),
  266.                     True
  267.                 )
  268.                 os.remove(test_support.TESTFN + "2")
  269.                 f = open(test_support.TESTFN + "2", "wb")
  270.                 f.write("bar")
  271.                 f.close()
  272.                 self.assertIs(
  273.                     posixpath.samefile(
  274.                         test_support.TESTFN + "1",
  275.                         test_support.TESTFN + "2"
  276.                     ),
  277.                     False
  278.                 )
  279.         finally:
  280.             if not f.close():
  281.                 f.close()
  282.  
  283.         self.assertRaises(TypeError, posixpath.samefile)
  284.  
  285.     def test_samestat(self):
  286.         f = open(test_support.TESTFN + "1", "wb")
  287.         try:
  288.             f.write("foo")
  289.             f.close()
  290.             self.assertIs(
  291.                 posixpath.samestat(
  292.                     os.stat(test_support.TESTFN + "1"),
  293.                     os.stat(test_support.TESTFN + "1")
  294.                 ),
  295.                 True
  296.             )
  297.             # If we don't have links, assume that os.stat() doesn't return resonable
  298.             # inode information and thus, that samefile() doesn't work
  299.             if hasattr(os, "symlink"):
  300.                 if hasattr(os, "symlink"):
  301.                     os.symlink(test_support.TESTFN + "1", test_support.TESTFN + "2")
  302.                     self.assertIs(
  303.                         posixpath.samestat(
  304.                             os.stat(test_support.TESTFN + "1"),
  305.                             os.stat(test_support.TESTFN + "2")
  306.                         ),
  307.                         True
  308.                     )
  309.                     os.remove(test_support.TESTFN + "2")
  310.                 f = open(test_support.TESTFN + "2", "wb")
  311.                 f.write("bar")
  312.                 f.close()
  313.                 self.assertIs(
  314.                     posixpath.samestat(
  315.                         os.stat(test_support.TESTFN + "1"),
  316.                         os.stat(test_support.TESTFN + "2")
  317.                     ),
  318.                     False
  319.                 )
  320.         finally:
  321.             if not f.close():
  322.                 f.close()
  323.  
  324.         self.assertRaises(TypeError, posixpath.samestat)
  325.  
  326.     def test_ismount(self):
  327.         self.assertIs(posixpath.ismount("/"), True)
  328.  
  329.         self.assertRaises(TypeError, posixpath.ismount)
  330.  
  331.     def test_expanduser(self):
  332.         self.assertEqual(posixpath.expanduser("foo"), "foo")
  333.         try:
  334.             import pwd
  335.         except ImportError:
  336.             pass
  337.         else:
  338.             self.assert_(isinstance(posixpath.expanduser("~/"), basestring))
  339.             # if home directory == root directory, this test makes no sense
  340.             if posixpath.expanduser("~") != '/':
  341.                 self.assertEqual(
  342.                     posixpath.expanduser("~") + "/",
  343.                     posixpath.expanduser("~/")
  344.                 )
  345.             self.assert_(isinstance(posixpath.expanduser("~root/"), basestring))
  346.             self.assert_(isinstance(posixpath.expanduser("~foo/"), basestring))
  347.  
  348.         self.assertRaises(TypeError, posixpath.expanduser)
  349.  
  350.     def test_expandvars(self):
  351.         oldenv = os.environ.copy()
  352.         try:
  353.             os.environ.clear()
  354.             os.environ["foo"] = "bar"
  355.             os.environ["{foo"] = "baz1"
  356.             os.environ["{foo}"] = "baz2"
  357.             self.assertEqual(posixpath.expandvars("foo"), "foo")
  358.             self.assertEqual(posixpath.expandvars("$foo bar"), "bar bar")
  359.             self.assertEqual(posixpath.expandvars("${foo}bar"), "barbar")
  360.             self.assertEqual(posixpath.expandvars("$[foo]bar"), "$[foo]bar")
  361.             self.assertEqual(posixpath.expandvars("$bar bar"), "$bar bar")
  362.             self.assertEqual(posixpath.expandvars("$?bar"), "$?bar")
  363.             self.assertEqual(posixpath.expandvars("${foo}bar"), "barbar")
  364.             self.assertEqual(posixpath.expandvars("$foo}bar"), "bar}bar")
  365.             self.assertEqual(posixpath.expandvars("${foo"), "${foo")
  366.             self.assertEqual(posixpath.expandvars("${{foo}}"), "baz1}")
  367.             self.assertEqual(posixpath.expandvars("$foo$foo"), "barbar")
  368.             self.assertEqual(posixpath.expandvars("$bar$bar"), "$bar$bar")
  369.         finally:
  370.             os.environ.clear()
  371.             os.environ.update(oldenv)
  372.  
  373.         self.assertRaises(TypeError, posixpath.expandvars)
  374.  
  375.     def test_normpath(self):
  376.         self.assertEqual(posixpath.normpath(""), ".")
  377.         self.assertEqual(posixpath.normpath("/"), "/")
  378.         self.assertEqual(posixpath.normpath("//"), "//")
  379.         self.assertEqual(posixpath.normpath("///"), "/")
  380.         self.assertEqual(posixpath.normpath("///foo/.//bar//"), "/foo/bar")
  381.         self.assertEqual(posixpath.normpath("///foo/.//bar//.//..//.//baz"), "/foo/baz")
  382.         self.assertEqual(posixpath.normpath("///..//./foo/.//bar"), "/foo/bar")
  383.  
  384.         self.assertRaises(TypeError, posixpath.normpath)
  385.  
  386.     def test_abspath(self):
  387.         self.assert_("foo" in posixpath.abspath("foo"))
  388.  
  389.         self.assertRaises(TypeError, posixpath.abspath)
  390.  
  391.     def test_realpath(self):
  392.         self.assert_("foo" in realpath("foo"))
  393.         self.assertRaises(TypeError, posixpath.realpath)
  394.  
  395.     if hasattr(os, "symlink"):
  396.         def test_realpath_basic(self):
  397.             # Basic operation.
  398.             try:
  399.                 os.symlink(ABSTFN+"1", ABSTFN)
  400.                 self.assertEqual(realpath(ABSTFN), ABSTFN+"1")
  401.             finally:
  402.                 test_support.unlink(ABSTFN)
  403.  
  404.         def test_realpath_symlink_loops(self):
  405.             # Bug #930024, return the path unchanged if we get into an infinite
  406.             # symlink loop.
  407.             try:
  408.                 old_path = abspath('.')
  409.                 os.symlink(ABSTFN, ABSTFN)
  410.                 self.assertEqual(realpath(ABSTFN), ABSTFN)
  411.  
  412.                 os.symlink(ABSTFN+"1", ABSTFN+"2")
  413.                 os.symlink(ABSTFN+"2", ABSTFN+"1")
  414.                 self.assertEqual(realpath(ABSTFN+"1"), ABSTFN+"1")
  415.                 self.assertEqual(realpath(ABSTFN+"2"), ABSTFN+"2")
  416.  
  417.                 # Test using relative path as well.
  418.                 os.chdir(dirname(ABSTFN))
  419.                 self.assertEqual(realpath(basename(ABSTFN)), ABSTFN)
  420.             finally:
  421.                 os.chdir(old_path)
  422.                 test_support.unlink(ABSTFN)
  423.                 test_support.unlink(ABSTFN+"1")
  424.                 test_support.unlink(ABSTFN+"2")
  425.  
  426.         def test_realpath_resolve_parents(self):
  427.             # We also need to resolve any symlinks in the parents of a relative
  428.             # path passed to realpath. E.g.: current working directory is
  429.             # /usr/doc with 'doc' being a symlink to /usr/share/doc. We call
  430.             # realpath("a"). This should return /usr/share/doc/a/.
  431.             try:
  432.                 old_path = abspath('.')
  433.                 os.mkdir(ABSTFN)
  434.                 os.mkdir(ABSTFN + "/y")
  435.                 os.symlink(ABSTFN + "/y", ABSTFN + "/k")
  436.  
  437.                 os.chdir(ABSTFN + "/k")
  438.                 self.assertEqual(realpath("a"), ABSTFN + "/y/a")
  439.             finally:
  440.                 os.chdir(old_path)
  441.                 test_support.unlink(ABSTFN + "/k")
  442.                 safe_rmdir(ABSTFN + "/y")
  443.                 safe_rmdir(ABSTFN)
  444.  
  445.         def test_realpath_resolve_before_normalizing(self):
  446.             # Bug #990669: Symbolic links should be resolved before we
  447.             # normalize the path. E.g.: if we have directories 'a', 'k' and 'y'
  448.             # in the following hierarchy:
  449.             # a/k/y
  450.             #
  451.             # and a symbolic link 'link-y' pointing to 'y' in directory 'a',
  452.             # then realpath("link-y/..") should return 'k', not 'a'.
  453.             try:
  454.                 old_path = abspath('.')
  455.                 os.mkdir(ABSTFN)
  456.                 os.mkdir(ABSTFN + "/k")
  457.                 os.mkdir(ABSTFN + "/k/y")
  458.                 os.symlink(ABSTFN + "/k/y", ABSTFN + "/link-y")
  459.  
  460.                 # Absolute path.
  461.                 self.assertEqual(realpath(ABSTFN + "/link-y/.."), ABSTFN + "/k")
  462.                 # Relative path.
  463.                 os.chdir(dirname(ABSTFN))
  464.                 self.assertEqual(realpath(basename(ABSTFN) + "/link-y/.."), ABSTFN + "/k")
  465.             finally:
  466.                 os.chdir(old_path)
  467.                 test_support.unlink(ABSTFN + "/link-y")
  468.                 safe_rmdir(ABSTFN + "/k/y")
  469.                 safe_rmdir(ABSTFN + "/k")
  470.                 safe_rmdir(ABSTFN)
  471.  
  472.         def test_realpath_resolve_first(self):
  473.             # Bug #1213894: The first component of the path, if not absolute,
  474.             # must be resolved too.
  475.  
  476.             try:
  477.                 old_path = abspath('.')
  478.                 os.mkdir(ABSTFN)
  479.                 os.mkdir(ABSTFN + "/k")
  480.                 os.symlink(ABSTFN, ABSTFN + "link")
  481.                 os.chdir(dirname(ABSTFN))
  482.  
  483.                 base = basename(ABSTFN)
  484.                 self.assertEqual(realpath(base + "link"), ABSTFN)
  485.                 self.assertEqual(realpath(base + "link/k"), ABSTFN + "/k")
  486.             finally:
  487.                 os.chdir(old_path)
  488.                 test_support.unlink(ABSTFN + "link")
  489.                 safe_rmdir(ABSTFN + "/k")
  490.                 safe_rmdir(ABSTFN)
  491.  
  492.     def test_relpath(self):
  493.         (real_getcwd, os.getcwd) = (os.getcwd, lambda: r"/home/user/bar")
  494.         try:
  495.             curdir = os.path.split(os.getcwd())[-1]
  496.             self.assertRaises(ValueError, posixpath.relpath, "")
  497.             self.assertEqual(posixpath.relpath("a"), "a")
  498.             self.assertEqual(posixpath.relpath(posixpath.abspath("a")), "a")
  499.             self.assertEqual(posixpath.relpath("a/b"), "a/b")
  500.             self.assertEqual(posixpath.relpath("../a/b"), "../a/b")
  501.             self.assertEqual(posixpath.relpath("a", "../b"), "../"+curdir+"/a")
  502.             self.assertEqual(posixpath.relpath("a/b", "../c"), "../"+curdir+"/a/b")
  503.             self.assertEqual(posixpath.relpath("a", "b/c"), "../../a")
  504.             self.assertEqual(posixpath.relpath("a", "a"), ".")
  505.         finally:
  506.             os.getcwd = real_getcwd
  507.  
  508. def test_main():
  509.     test_support.run_unittest(PosixPathTest)
  510.  
  511. if __name__=="__main__":
  512.     test_main()
  513.