1 import unittest

     2 from test import test_support

     3 import os

     4 import genericpath

     5 

     6 class AllCommonTest(unittest.TestCase):

     7 

     8     def assertIs(self, a, b):

     9         self.assert_(a is b)

    10 

    11     def test_commonprefix(self):

    12         self.assertEqual(

    13             genericpath.commonprefix([]),

    14             ""

    15         )

    16         self.assertEqual(

    17             genericpath.commonprefix(["/home/swenson/spam", "/home/swen/spam"]),

    18             "/home/swen"

    19         )

    20         self.assertEqual(

    21             genericpath.commonprefix(["/home/swen/spam", "/home/swen/eggs"]),

    22             "/home/swen/"

    23         )

    24         self.assertEqual(

    25             genericpath.commonprefix(["/home/swen/spam", "/home/swen/spam"]),

    26             "/home/swen/spam"

    27         )

    28 

    29     def test_getsize(self):

    30         f = open(test_support.TESTFN, "wb")

    31         try:

    32             f.write("foo")

    33             f.close()

    34             self.assertEqual(genericpath.getsize(test_support.TESTFN), 3)

    35         finally:

    36             if not f.closed:

    37                 f.close()

    38             os.remove(test_support.TESTFN)

    39 

    40     def test_time(self):

    41         f = open(test_support.TESTFN, "wb")

    42         try:

    43             f.write("foo")

    44             f.close()

    45             f = open(test_support.TESTFN, "ab")

    46             f.write("bar")

    47             f.close()

    48             f = open(test_support.TESTFN, "rb")

    49             d = f.read()

    50             f.close()

    51             self.assertEqual(d, "foobar")

    52 

    53             self.assert_(

    54                 genericpath.getctime(test_support.TESTFN) <=

    55                 genericpath.getmtime(test_support.TESTFN)

    56             )

    57         finally:

    58             if not f.closed:

    59                 f.close()

    60             os.remove(test_support.TESTFN)

    61 

    62     def test_exists(self):

    63         self.assertIs(genericpath.exists(test_support.TESTFN), False)

    64         f = open(test_support.TESTFN, "wb")

    65         try:

    66             f.write("foo")

    67             f.close()

    68             self.assertIs(genericpath.exists(test_support.TESTFN), True)

    69         finally:

    70             if not f.close():

    71                 f.close()

    72             try:

    73                 os.remove(test_support.TESTFN)

    74             except os.error:

    75                 pass

    76 

    77         self.assertRaises(TypeError, genericpath.exists)

    78 

    79     def test_isdir(self):

    80         self.assertIs(genericpath.isdir(test_support.TESTFN), False)

    81         f = open(test_support.TESTFN, "wb")

    82         try:

    83             f.write("foo")

    84             f.close()

    85             self.assertIs(genericpath.isdir(test_support.TESTFN), False)

    86             os.remove(test_support.TESTFN)

    87             os.mkdir(test_support.TESTFN)

    88             self.assertIs(genericpath.isdir(test_support.TESTFN), True)

    89             os.rmdir(test_support.TESTFN)

    90         finally:

    91             if not f.close():

    92                 f.close()

    93             try:

    94                 os.remove(test_support.TESTFN)

    95             except os.error:

    96                 pass

    97             try:

    98                 os.rmdir(test_support.TESTFN)

    99             except os.error:

   100                 pass

   101 

   102         self.assertRaises(TypeError, genericpath.isdir)

   103 

   104     def test_isfile(self):

   105         self.assertIs(genericpath.isfile(test_support.TESTFN), False)

   106         f = open(test_support.TESTFN, "wb")

   107         try:

   108             f.write("foo")

   109             f.close()

   110             self.assertIs(genericpath.isfile(test_support.TESTFN), True)

   111             os.remove(test_support.TESTFN)

   112             os.mkdir(test_support.TESTFN)

   113             self.assertIs(genericpath.isfile(test_support.TESTFN), False)

   114             os.rmdir(test_support.TESTFN)

   115         finally:

   116             if not f.close():

   117                 f.close()

   118             try:

   119                 os.remove(test_support.TESTFN)

   120             except os.error:

   121                 pass

   122             try:

   123                 os.rmdir(test_support.TESTFN)

   124             except os.error:

   125                 pass

   126 

   127         self.assertRaises(TypeError, genericpath.isdir)

   128 

   129         def test_samefile(self):

   130             f = open(test_support.TESTFN + "1", "wb")

   131             try:

   132                 f.write("foo")

   133                 f.close()

   134                 self.assertIs(

   135                     genericpath.samefile(

   136                         test_support.TESTFN + "1",

   137                         test_support.TESTFN + "1"

   138                     ),

   139                     True

   140                 )

   141                 # If we don't have links, assume that os.stat doesn't return resonable

   142                 # inode information and thus, that samefile() doesn't work

   143                 if hasattr(os, "symlink"):

   144                     os.symlink(

   145                         test_support.TESTFN + "1",

   146                         test_support.TESTFN + "2"

   147                     )

   148                     self.assertIs(

   149                         genericpath.samefile(

   150                             test_support.TESTFN + "1",

   151                             test_support.TESTFN + "2"

   152                         ),

   153                         True

   154                     )

   155                     os.remove(test_support.TESTFN + "2")

   156                     f = open(test_support.TESTFN + "2", "wb")

   157                     f.write("bar")

   158                     f.close()

   159                     self.assertIs(

   160                         genericpath.samefile(

   161                             test_support.TESTFN + "1",

   162                             test_support.TESTFN + "2"

   163                         ),

   164                         False

   165                     )

   166             finally:

   167                 if not f.close():

   168                     f.close()

   169                 try:

   170                     os.remove(test_support.TESTFN + "1")

   171                 except os.error:

   172                     pass

   173                 try:

   174                     os.remove(test_support.TESTFN + "2")

   175                 except os.error:

   176                     pass

   177 

   178             self.assertRaises(TypeError, genericpath.samefile)

   179 

   180 def test_main():

   181     test_support.run_unittest(AllCommonTest)

   182 

   183 if __name__=="__main__":

   184     test_main()