def testMakeDirs(self): d = path(self.tempdir) # Placeholder file so that when removedirs() is called, # it doesn't remove the temporary directory itself. tempf = d / 'temp.txt' tempf.touch() try: foo = d / 'foo' boz = foo / 'bar' / 'baz' / 'boz' boz.makedirs() try: self.assert_(boz.isdir()) finally: boz.removedirs() self.failIf(foo.exists()) self.assert_(d.exists()) foo.mkdir(0o750) boz.makedirs(0o700) try: self.assert_(boz.isdir()) finally: boz.removedirs() self.failIf(foo.exists()) self.assert_(d.exists()) finally: os.remove(tempf)
def testMethods(self): # .abspath() self.assertEqual(path(os.curdir).abspath(), os.getcwd()) # .getcwd() cwd = path.cwd() self.assert_(isinstance(cwd, path)) self.assertEqual(cwd, os.getcwd())
def testTouch(self): # NOTE: This test takes a long time to run (~10 seconds). # It sleeps several seconds because on Windows, the resolution # of a file's mtime and ctime is about 2 seconds. # # atime isn't tested because on Windows the resolution of atime # is something like 24 hours. sleep_time = 2.0 if is_windows: sleep_time = 5.0 d = path(self.tempdir) f = d / 'test.txt' t0 = time.time() - sleep_time / 2 f.touch() t1 = time.time() + sleep_time / 2 try: self.assert_(f.exists()) self.assert_(f.isfile()) self.assertEqual(f.size(), 0) self.assert_(t0 <= f.mtime() <= t1) if hasattr(os.path, 'getctime'): ct = f.ctime() self.assert_(t0 <= ct <= t1) time.sleep(sleep_time) fobj = file(f, 'ab') fobj.write('some bytes') fobj.close() time.sleep(sleep_time) f_new = d / 'test_new.txt' f_new.touch() self.assert_(f_new.newer(f)) t2 = time.time() - sleep_time / 2 f.touch() t3 = time.time() + sleep_time / 2 assert t0 <= t1 < t2 <= t3 # sanity check self.assert_(f.exists()) self.assert_(f.isfile()) self.assertEqual(f.size(), 10) self.assert_(t2 <= f.mtime() <= t3) if hasattr(os.path, 'getctime'): ct2 = f.ctime() if os.name == 'nt': # On Windows, "ctime" is CREATION time self.assertEqual(ct, ct2) self.assert_(ct2 < t2) else: # On other systems, it might be the CHANGE time # (especially on Unix, time of inode changes) self.failUnless(ct == ct2 or ct2 == f.mtime()) finally: f.remove()
def testRelpath(self): root = path(p(nt='C:\\', posix='/')) foo = root / 'foo' quux = foo / 'quux' bar = foo / 'bar' boz = bar / 'Baz' / 'Boz' up = path(os.pardir) # basics self.assertEqual(root.relpathto(boz), path('foo')/'bar'/'Baz'/'Boz') self.assertEqual(bar.relpathto(boz), path('Baz')/'Boz') self.assertEqual(quux.relpathto(boz), up/'bar'/'Baz'/'Boz') self.assertEqual(boz.relpathto(quux), up/up/up/'quux') self.assertEqual(boz.relpathto(bar), up/up) # x.relpathto(x) == curdir self.assertEqual(root.relpathto(root), os.curdir) self.assertEqual(boz.relpathto(boz), os.curdir) # Make sure case is properly noted (or ignored) self.assertEqual(boz.relpathto(boz.normcase()), os.curdir) # relpath() cwd = path(os.getcwd()) self.assertEqual(boz.relpath(), cwd.relpathto(boz)) if os.name == 'nt': # Check relpath across drives. d = path('D:\\') self.assertEqual(d.relpathto(boz), boz)
def testPatterns(self): d = path(self.tempdir) names = [ 'x.tmp', 'x.xtmp', 'x2g', 'x22', 'x.txt' ] dirs = [d, d/'xdir', d/'xdir.tmp', d/'xdir.tmp'/'xsubdir'] for e in dirs: if not e.isdir(): e.makedirs() for name in names: (e/name).touch() self.assertList(d.listdir('*.tmp'), [d/'x.tmp', d/'xdir.tmp']) self.assertList(d.files('*.tmp'), [d/'x.tmp']) self.assertList(d.dirs('*.tmp'), [d/'xdir.tmp']) self.assertList(d.walk(), [e for e in dirs if e != d] + [e/n for e in dirs for n in names]) self.assertList(d.walk('*.tmp'), [e/'x.tmp' for e in dirs] + [d/'xdir.tmp']) self.assertList(d.walkfiles('*.tmp'), [e/'x.tmp' for e in dirs]) self.assertList(d.walkdirs('*.tmp'), [d/'xdir.tmp'])
def testProperties(self): # Create sample path object. f = p(nt='C:\\Program Files\\Python\\Lib\\xyzzy.py', posix='/usr/local/python/lib/xyzzy.py') f = path(f) # .parent self.assertEqual(f.parent, p(nt='C:\\Program Files\\Python\\Lib', posix='/usr/local/python/lib')) # .name self.assertEqual(f.name, 'xyzzy.py') self.assertEqual(f.parent.name, p(nt='Lib', posix='lib')) # .ext self.assertEqual(f.ext, '.py') self.assertEqual(f.parent.ext, '') # .drive self.assertEqual(f.drive, p(nt='C:', posix=''))
def testListing(self): d = path(self.tempdir) self.assertEqual(d.listdir(), []) f = 'testfile.txt' af = d / f self.assertEqual(af, os.path.join(d, f)) af.touch() try: self.assert_(af.exists()) self.assertEqual(d.listdir(), [af]) # .glob() self.assertEqual(d.glob('testfile.txt'), [af]) self.assertEqual(d.glob('test*.txt'), [af]) self.assertEqual(d.glob('*.txt'), [af]) self.assertEqual(d.glob('*txt'), [af]) self.assertEqual(d.glob('*'), [af]) self.assertEqual(d.glob('*.html'), []) self.assertEqual(d.glob('testfile'), []) finally: af.remove() # Try a test with 20 files files = [d / ('%d.txt' % i) for i in range(20)] for f in files: fobj = file(f, 'w') fobj.write('some text\n') fobj.close() try: files2 = d.listdir() files.sort() files2.sort() self.assertEqual(files, files2) finally: for f in files: try: f.remove() except: pass
def testStringCompatibility(self): """ Test compatibility with ordinary strings. """ x = path('xyzzy') self.assert_(x == 'xyzzy') self.assert_(x == 'xyzzy') # sorting items = [path('fhj'), path('fgh'), 'E', path('d'), 'A', path('B'), 'c'] items.sort() self.assert_(items == ['A', 'B', 'E', 'c', 'd', 'fgh', 'fhj']) # Test p1/p1. p1 = path("foo") p2 = path("bar") self.assertEqual(p1/p2, p(nt='foo\\bar', posix='foo/bar'))
def testUNC(self): if hasattr(os.path, 'splitunc'): p = path(r'\\python1\share1\dir1\file1.txt') self.assert_(p.uncshare == r'\\python1\share1') self.assert_(p.splitunc() == os.path.splitunc(str(p)))
def testUnicode(self): d = path(self.tempdir) p = d / 'unicode.txt' def test(enc): """ Test that path works with the specified encoding, which must be capable of representing the entire range of Unicode codepoints. """ given = (u'Hello world\n' u'\u0d0a\u0a0d\u0d15\u0a15\r\n' u'\u0d0a\u0a0d\u0d15\u0a15\x85' u'\u0d0a\u0a0d\u0d15\u0a15\u2028' u'\r' u'hanging') clean = (u'Hello world\n' u'\u0d0a\u0a0d\u0d15\u0a15\n' u'\u0d0a\u0a0d\u0d15\u0a15\n' u'\u0d0a\u0a0d\u0d15\u0a15\n' u'\n' u'hanging') givenLines = [ u'Hello world\n', u'\u0d0a\u0a0d\u0d15\u0a15\r\n', u'\u0d0a\u0a0d\u0d15\u0a15\x85', u'\u0d0a\u0a0d\u0d15\u0a15\u2028', u'\r', u'hanging' ] expectedLines = [ u'Hello world\n', u'\u0d0a\u0a0d\u0d15\u0a15\n', u'\u0d0a\u0a0d\u0d15\u0a15\n', u'\u0d0a\u0a0d\u0d15\u0a15\n', u'\n', u'hanging' ] expectedLines2 = [ u'Hello world', u'\u0d0a\u0a0d\u0d15\u0a15', u'\u0d0a\u0a0d\u0d15\u0a15', u'\u0d0a\u0a0d\u0d15\u0a15', u'', u'hanging' ] # write bytes manually to file f = codecs.open(p, 'w', enc) f.write(given) f.close() # test all 3 path read-fully functions, including # path.lines() in unicode mode. self.assertEqual(p.bytes(), given.encode(enc)) self.assertEqual(p.text(enc), clean) self.assertEqual(p.lines(enc), expectedLines) self.assertEqual(p.lines(enc, retain=False), expectedLines2) # If this is UTF-16, that's enough. # The rest of these will unfortunately fail because append=True mode # causes an extra BOM to be written in the middle of the file. # UTF-16 is the only encoding that has this problem. if enc == 'UTF-16': return # Write Unicode to file using path.write_text(). cleanNoHanging = clean + u'\n' # This test doesn't work with a hanging line. p.write_text(cleanNoHanging, enc) p.write_text(cleanNoHanging, enc, append=True) # Check the result. expectedBytes = 2 * cleanNoHanging.replace('\n', os.linesep).encode(enc) expectedLinesNoHanging = expectedLines[:] expectedLinesNoHanging[-1] += '\n' self.assertEqual(p.bytes(), expectedBytes) self.assertEqual(p.text(enc), 2 * cleanNoHanging) self.assertEqual(p.lines(enc), 2 * expectedLinesNoHanging) self.assertEqual(p.lines(enc, retain=False), 2 * expectedLines2) # Write Unicode to file using path.write_lines(). # The output in the file should be exactly the same as last time. p.write_lines(expectedLines, enc) p.write_lines(expectedLines2, enc, append=True) # Check the result. self.assertEqual(p.bytes(), expectedBytes) # Now: same test, but using various newline sequences. # If linesep is being properly applied, these will be converted # to the platform standard newline sequence. p.write_lines(givenLines, enc) p.write_lines(givenLines, enc, append=True) # Check the result. self.assertEqual(p.bytes(), expectedBytes) # Same test, using newline sequences that are different # from the platform default. def testLinesep(eol): p.write_lines(givenLines, enc, linesep=eol) p.write_lines(givenLines, enc, linesep=eol, append=True) expected = 2 * cleanNoHanging.replace(u'\n', eol).encode(enc) self.assertEqual(p.bytes(), expected) testLinesep(u'\n') testLinesep(u'\r') testLinesep(u'\r\n') testLinesep(u'\x0d\x85') # Again, but with linesep=None. p.write_lines(givenLines, enc, linesep=None) p.write_lines(givenLines, enc, linesep=None, append=True) # Check the result. expectedBytes = 2 * given.encode(enc) self.assertEqual(p.bytes(), expectedBytes) self.assertEqual(p.text(enc), 2 * clean) expectedResultLines = expectedLines[:] expectedResultLines[-1] += expectedLines[0] expectedResultLines += expectedLines[1:] self.assertEqual(p.lines(enc), expectedResultLines) test('UTF-8') test('UTF-16BE') test('UTF-16LE') test('UTF-16')
def testShutil(self): # Note: This only tests the methods exist and do roughly what # they should, neglecting the details as they are shutil's # responsibility. d = path(self.tempdir) testDir = d / 'testdir' testFile = testDir / 'testfile.txt' testA = testDir / 'A' testCopy = testA / 'testcopy.txt' testLink = testA / 'testlink.txt' testInstall = testA / 'testinstall.txt' testB = testDir / 'B' testC = testB / 'C' testCopyOfLink = testC / testA.relpathto(testLink) # Create test dirs and a file testDir.mkdir() testA.mkdir() testB.mkdir() f = open(testFile, 'w') f.write('x' * 10000) f.close() # Test simple file copying. testFile.copyfile(testCopy) self.assert_(testCopy.isfile()) self.assert_(testFile.bytes() == testCopy.bytes()) # Test copying into a directory. testCopy2 = testA / testFile.name testFile.copy(testA) self.assert_(testCopy2.isfile()) self.assert_(testFile.bytes() == testCopy2.bytes()) # Test install file testFile.install(testInstall, chmod=0740) stats = stat.S_IMODE(testInstall.stat().st_mode) self.assert_(stats == stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP) testInstall.unlink() # Make a link for the next test to use. if hasattr(os, 'symlink'): testFile.symlink(testLink) else: testFile.copy(testLink) # fallback # Test copying directory tree. testA.copytree(testC) self.assert_(testC.isdir()) self.assertSetsEqual( testC.listdir(), [testC / testCopy.name, testC / testFile.name, testCopyOfLink]) self.assert_(not testCopyOfLink.islink()) # Clean up for another try. testC.rmtree() self.assert_(not testC.exists()) # Copy again, preserving symlinks. testA.copytree(testC, True) self.assert_(testC.isdir()) self.assertSetsEqual( testC.listdir(), [testC / testCopy.name, testC / testFile.name, testCopyOfLink]) if hasattr(os, 'symlink'): self.assert_(testCopyOfLink.islink()) self.assert_(testCopyOfLink.readlink() == testFile) # Clean up. testDir.rmtree() self.assert_(not testDir.exists()) self.assertList(d.listdir(), [])
def testUnicode(self): d = path(self.tempdir) p = d/'unicode.txt' def test(enc): """ Test that path works with the specified encoding, which must be capable of representing the entire range of Unicode codepoints. """ given = ('Hello world\n' '\u0d0a\u0a0d\u0d15\u0a15\r\n' '\u0d0a\u0a0d\u0d15\u0a15\x85' '\u0d0a\u0a0d\u0d15\u0a15\u2028' '\r' 'hanging') clean = ('Hello world\n' '\u0d0a\u0a0d\u0d15\u0a15\n' '\u0d0a\u0a0d\u0d15\u0a15\n' '\u0d0a\u0a0d\u0d15\u0a15\n' '\n' 'hanging') givenLines = [ 'Hello world\n', '\u0d0a\u0a0d\u0d15\u0a15\r\n', '\u0d0a\u0a0d\u0d15\u0a15\x85', '\u0d0a\u0a0d\u0d15\u0a15\u2028', '\r', 'hanging'] expectedLines = [ 'Hello world\n', '\u0d0a\u0a0d\u0d15\u0a15\n', '\u0d0a\u0a0d\u0d15\u0a15\n', '\u0d0a\u0a0d\u0d15\u0a15\n', '\n', 'hanging'] expectedLines2 = [ 'Hello world', '\u0d0a\u0a0d\u0d15\u0a15', '\u0d0a\u0a0d\u0d15\u0a15', '\u0d0a\u0a0d\u0d15\u0a15', '', 'hanging'] # write bytes manually to file f = codecs.open(p, 'w', enc) f.write(given) f.close() # test all 3 path read-fully functions, including # path.lines() in unicode mode. self.assertEqual(p.bytes(), given.encode(enc)) self.assertEqual(p.text(enc), clean) self.assertEqual(p.lines(enc), expectedLines) self.assertEqual(p.lines(enc, retain=False), expectedLines2) # If this is UTF-16, that's enough. # The rest of these will unfortunately fail because append=True mode # causes an extra BOM to be written in the middle of the file. # UTF-16 is the only encoding that has this problem. if enc == 'UTF-16': return # Write Unicode to file using path.write_text(). cleanNoHanging = clean + '\n' # This test doesn't work with a hanging line. p.write_text(cleanNoHanging, enc) p.write_text(cleanNoHanging, enc, append=True) # Check the result. expectedBytes = 2 * cleanNoHanging.replace('\n', os.linesep).encode(enc) expectedLinesNoHanging = expectedLines[:] expectedLinesNoHanging[-1] += '\n' self.assertEqual(p.bytes(), expectedBytes) self.assertEqual(p.text(enc), 2 * cleanNoHanging) self.assertEqual(p.lines(enc), 2 * expectedLinesNoHanging) self.assertEqual(p.lines(enc, retain=False), 2 * expectedLines2) # Write Unicode to file using path.write_lines(). # The output in the file should be exactly the same as last time. p.write_lines(expectedLines, enc) p.write_lines(expectedLines2, enc, append=True) # Check the result. self.assertEqual(p.bytes(), expectedBytes) # Now: same test, but using various newline sequences. # If linesep is being properly applied, these will be converted # to the platform standard newline sequence. p.write_lines(givenLines, enc) p.write_lines(givenLines, enc, append=True) # Check the result. self.assertEqual(p.bytes(), expectedBytes) # Same test, using newline sequences that are different # from the platform default. def testLinesep(eol): p.write_lines(givenLines, enc, linesep=eol) p.write_lines(givenLines, enc, linesep=eol, append=True) expected = 2 * cleanNoHanging.replace('\n', eol).encode(enc) self.assertEqual(p.bytes(), expected) testLinesep('\n') testLinesep('\r') testLinesep('\r\n') testLinesep('\x0d\x85') # Again, but with linesep=None. p.write_lines(givenLines, enc, linesep=None) p.write_lines(givenLines, enc, linesep=None, append=True) # Check the result. expectedBytes = 2 * given.encode(enc) self.assertEqual(p.bytes(), expectedBytes) self.assertEqual(p.text(enc), 2 * clean) expectedResultLines = expectedLines[:] expectedResultLines[-1] += expectedLines[0] expectedResultLines += expectedLines[1:] self.assertEqual(p.lines(enc), expectedResultLines) test('UTF-8') test('UTF-16BE') test('UTF-16LE') test('UTF-16')
def testShutil(self): # Note: This only tests the methods exist and do roughly what # they should, neglecting the details as they are shutil's # responsibility. d = path(self.tempdir) testDir = d / 'testdir' testFile = testDir / 'testfile.txt' testA = testDir / 'A' testCopy = testA / 'testcopy.txt' testLink = testA / 'testlink.txt' testInstall = testA / 'testinstall.txt' testB = testDir / 'B' testC = testB / 'C' testCopyOfLink = testC / testA.relpathto(testLink) # Create test dirs and a file testDir.mkdir() testA.mkdir() testB.mkdir() f = open(testFile, 'w') f.write('x' * 10000) f.close() # Test simple file copying. testFile.copyfile(testCopy) self.assert_(testCopy.isfile()) self.assert_(testFile.bytes() == testCopy.bytes()) # Test copying into a directory. testCopy2 = testA / testFile.name testFile.copy(testA) self.assert_(testCopy2.isfile()) self.assert_(testFile.bytes() == testCopy2.bytes()) # Test install file testFile.install(testInstall, chmod=0o740) stats = stat.S_IMODE(testInstall.stat().st_mode) self.assert_(stats == stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP) testInstall.unlink() # Make a link for the next test to use. if hasattr(os, 'symlink'): testFile.symlink(testLink) else: testFile.copy(testLink) # fallback # Test copying directory tree. testA.copytree(testC) self.assert_(testC.isdir()) self.assertSetsEqual( testC.listdir(), [testC / testCopy.name, testC / testFile.name, testCopyOfLink]) self.assert_(not testCopyOfLink.islink()) # Clean up for another try. testC.rmtree() self.assert_(not testC.exists()) # Copy again, preserving symlinks. testA.copytree(testC, True) self.assert_(testC.isdir()) self.assertSetsEqual( testC.listdir(), [testC / testCopy.name, testC / testFile.name, testCopyOfLink]) if hasattr(os, 'symlink'): self.assert_(testCopyOfLink.islink()) self.assert_(testCopyOfLink.readlink() == testFile) # Clean up. testDir.rmtree() self.assert_(not testDir.exists()) self.assertList(d.listdir(), [])