[Jython-checkins] jython: Remove Jython-specific pythonpath, test_pythonpath; update pwd to support
jim.baker
jython-checkins at python.org
Fri Mar 13 22:24:47 CET 2015
https://hg.python.org/jython/rev/8c1a3b72913e
changeset: 7611:8c1a3b72913e
user: Jim Baker <jim.baker at rackspace.com>
date: Fri Mar 13 15:24:16 2015 -0600
summary:
Remove Jython-specific pythonpath, test_pythonpath; update pwd to support unicode
Fixes http://bugs.jython.org/issue2274
files:
CPythonLib.includes | 1 +
Lib/posixpath.py | 513 ------------------------
Lib/pwd.py | 8 +-
Lib/test/test_posixpath.py | 521 -------------------------
4 files changed, 5 insertions(+), 1038 deletions(-)
diff --git a/CPythonLib.includes b/CPythonLib.includes
--- a/CPythonLib.includes
+++ b/CPythonLib.includes
@@ -116,6 +116,7 @@
plistlib.py
poplib.py
posixfile.py
+posixpath.py
pprint.py
profile.py
pstats.py
diff --git a/Lib/posixpath.py b/Lib/posixpath.py
deleted file mode 100644
--- a/Lib/posixpath.py
+++ /dev/null
@@ -1,513 +0,0 @@
-"""Common operations on Posix pathnames.
-
-Instead of importing this module directly, import os and refer to
-this module as os.path. The "os.path" name is an alias for this
-module on Posix systems; on other systems (e.g. Mac, Windows),
-os.path provides the same operations in a manner specific to that
-platform, and is an alias to another module (e.g. macpath, ntpath).
-
-Some of this can actually be useful on non-Posix systems too, e.g.
-for manipulation of the pathname component of URLs.
-"""
-
-import os
-import stat
-
-__all__ = ["normcase","isabs","join","splitdrive","split","splitext",
- "basename","dirname","commonprefix","getsize","getmtime",
- "getatime","getctime","islink","exists","lexists","isdir","isfile",
- "walk","expanduser","expandvars","normpath","abspath",
- "samefile",
- "curdir","pardir","sep","pathsep","defpath","altsep","extsep",
- "devnull","realpath","supports_unicode_filenames", "relpath"]
-
-# strings representing various path-related bits and pieces
-curdir = '.'
-pardir = '..'
-extsep = '.'
-sep = '/'
-pathsep = ':'
-defpath = ':/bin:/usr/bin'
-altsep = None
-devnull = '/dev/null'
-
-# Normalize the case of a pathname. Trivial in Posix, string.lower on Mac.
-# On MS-DOS this may also turn slashes into backslashes; however, other
-# normalizations (such as optimizing '../' away) are not allowed
-# (another function should be defined to do that).
-
-def normcase(s):
- """Normalize case of pathname. Has no effect under Posix"""
- return s
-
-
-# Return whether a path is absolute.
-# Trivial in Posix, harder on the Mac or MS-DOS.
-
-def isabs(s):
- """Test whether a path is absolute"""
- return s.startswith('/')
-
-
-# Join pathnames.
-# Ignore the previous parts if a part is absolute.
-# Insert a '/' unless the first part is empty or already ends in '/'.
-
-def join(a, *p):
- """Join two or more pathname components, inserting '/' as needed"""
- path = a
- for b in p:
- if b.startswith('/'):
- path = b
- elif path == '' or path.endswith('/'):
- path += b
- else:
- path += '/' + b
- return path
-
-
-# Split a path in head (everything up to the last '/') and tail (the
-# rest). If the path ends in '/', tail will be empty. If there is no
-# '/' in the path, head will be empty.
-# Trailing '/'es are stripped from head unless it is the root.
-
-def split(p):
- """Split a pathname. Returns tuple "(head, tail)" where "tail" is
- everything after the final slash. Either part may be empty."""
- i = p.rfind('/') + 1
- head, tail = p[:i], p[i:]
- if head and head != '/'*len(head):
- head = head.rstrip('/')
- return head, tail
-
-
-# Split a path in root and extension.
-# The extension is everything starting at the last dot in the last
-# pathname component; the root is everything before that.
-# It is always true that root + ext == p.
-
-def splitext(p):
- """Split the extension from a pathname. Extension is everything from the
- last dot to the end. Returns "(root, ext)", either part may be empty."""
- i = p.rfind('.')
- if i<=p.rfind('/'):
- return p, ''
- else:
- return p[:i], p[i:]
-
-
-# Split a pathname into a drive specification and the rest of the
-# path. Useful on DOS/Windows/NT; on Unix, the drive is always empty.
-
-def splitdrive(p):
- """Split a pathname into drive and path. On Posix, drive is always
- empty."""
- return '', p
-
-
-# Return the tail (basename) part of a path.
-
-def basename(p):
- """Returns the final component of a pathname"""
- return split(p)[1]
-
-
-# Return the head (dirname) part of a path.
-
-def dirname(p):
- """Returns the directory component of a pathname"""
- return split(p)[0]
-
-
-# Return the longest prefix of all list elements.
-
-def commonprefix(m):
- "Given a list of pathnames, returns the longest common leading component"
- if not m: return ''
- s1 = min(m)
- s2 = max(m)
- n = min(len(s1), len(s2))
- for i in xrange(n):
- if s1[i] != s2[i]:
- return s1[:i]
- return s1[:n]
-
-# Get size, mtime, atime of files.
-
-def getsize(filename):
- """Return the size of a file, reported by os.stat()."""
- return os.stat(filename).st_size
-
-def getmtime(filename):
- """Return the last modification time of a file, reported by os.stat()."""
- return os.stat(filename).st_mtime
-
-def getatime(filename):
- """Return the last access time of a file, reported by os.stat()."""
- return os.stat(filename).st_atime
-
-def getctime(filename):
- """Return the metadata change time of a file, reported by os.stat()."""
- return os.stat(filename).st_ctime
-
-# Is a path a symbolic link?
-# This will always return false on systems where os.lstat doesn't exist.
-
-def islink(path):
- """Test whether a path is a symbolic link"""
- try:
- st = os.lstat(path)
- except (os.error, AttributeError):
- return False
- return stat.S_ISLNK(st.st_mode)
-
-
-# Does a path exist?
-# This is false for dangling symbolic links.
-
-def exists(path):
- """Test whether a path exists. Returns False for broken symbolic links"""
- try:
- st = os.stat(path)
- except os.error:
- return False
- return True
-
-
-# Being true for dangling symbolic links is also useful.
-
-def lexists(path):
- """Test whether a path exists. Returns True for broken symbolic links"""
- try:
- st = os.lstat(path)
- except os.error:
- return False
- return True
-
-
-# Is a path a directory?
-# This follows symbolic links, so both islink() and isdir() can be true
-# for the same path.
-
-def isdir(path):
- """Test whether a path is a directory"""
- try:
- st = os.stat(path)
- except os.error:
- return False
- return stat.S_ISDIR(st.st_mode)
-
-
-# Is a path a regular file?
-# This follows symbolic links, so both islink() and isfile() can be true
-# for the same path.
-
-def isfile(path):
- """Test whether a path is a regular file"""
- try:
- st = os.stat(path)
- except os.error:
- return False
- return stat.S_ISREG(st.st_mode)
-
-
-# Are two filenames really pointing to the same file?
-
-if not os._native_posix:
- import java.io.File
- import java.io.IOException
- from org.python.core.Py import newString
-
- def samefile(f1, f2):
- """Test whether two pathnames reference the same actual file"""
- canon1 = newString(java.io.File(_ensure_str(f1)).getCanonicalPath())
- canon2 = newString(java.io.File(_ensure_str(f2)).getCanonicalPath())
- return canon1 == canon2
-else:
- def samefile(f1, f2):
- """Test whether two pathnames reference the same actual file"""
- s1 = os.stat(f1)
- s2 = os.stat(f2)
- return samestat(s1, s2)
-
-
-# XXX: Jython currently lacks fstat
-if hasattr(os, 'fstat'):
- # Are two open files really referencing the same file?
- # (Not necessarily the same file descriptor!)
-
- def sameopenfile(fp1, fp2):
- """Test whether two open file objects reference the same file"""
- s1 = os.fstat(fp1)
- s2 = os.fstat(fp2)
- return samestat(s1, s2)
-
- __all__.append("sameopenfile")
-
-
-# XXX: Pure Java stat lacks st_ino/st_dev
-if os._native_posix:
- # Are two stat buffers (obtained from stat, fstat or lstat)
- # describing the same file?
-
- def samestat(s1, s2):
- """Test whether two stat buffers reference the same file"""
- return s1.st_ino == s2.st_ino and \
- s1.st_dev == s2.st_dev
-
-
- # Is a path a mount point?
- # (Does this work for all UNIXes? Is it even guaranteed to work by Posix?)
-
- def ismount(path):
- """Test whether a path is a mount point"""
- try:
- s1 = os.lstat(path)
- s2 = os.lstat(join(path, '..'))
- except os.error:
- return False # It doesn't exist -- so not a mount point :-)
- dev1 = s1.st_dev
- dev2 = s2.st_dev
- if dev1 != dev2:
- return True # path/.. on a different device as path
- ino1 = s1.st_ino
- ino2 = s2.st_ino
- if ino1 == ino2:
- return True # path/.. is the same i-node as path
- return False
-
- __all__.extend(["samestat", "ismount"])
-
-
-# Directory tree walk.
-# For each directory under top (including top itself, but excluding
-# '.' and '..'), func(arg, dirname, filenames) is called, where
-# dirname is the name of the directory and filenames is the list
-# of files (and subdirectories etc.) in the directory.
-# The func may modify the filenames list, to implement a filter,
-# or to impose a different order of visiting.
-
-def walk(top, func, arg):
- """Directory tree walk with callback function.
-
- For each directory in the directory tree rooted at top (including top
- itself, but excluding '.' and '..'), call func(arg, dirname, fnames).
- dirname is the name of the directory, and fnames a list of the names of
- the files and subdirectories in dirname (excluding '.' and '..'). func
- may modify the fnames list in-place (e.g. via del or slice assignment),
- and walk will only recurse into the subdirectories whose names remain in
- fnames; this can be used to implement a filter, or to impose a specific
- order of visiting. No semantics are defined for, or required of, arg,
- beyond that arg is always passed to func. It can be used, e.g., to pass
- a filename pattern, or a mutable object designed to accumulate
- statistics. Passing None for arg is common."""
-
- try:
- names = os.listdir(top)
- except os.error:
- return
- func(arg, top, names)
- for name in names:
- name = join(top, name)
- try:
- st = os.lstat(name)
- except os.error:
- continue
- if stat.S_ISDIR(st.st_mode):
- walk(name, func, arg)
-
-
-# Expand paths beginning with '~' or '~user'.
-# '~' means $HOME; '~user' means that user's home directory.
-# If the path doesn't begin with '~', or if the user or $HOME is unknown,
-# the path is returned unchanged (leaving error reporting to whatever
-# function is called with the expanded path as argument).
-# See also module 'glob' for expansion of *, ? and [...] in pathnames.
-# (A function should also be defined to do full *sh-style environment
-# variable expansion.)
-
-def expanduser(path):
- """Expand ~ and ~user constructions. If user or $HOME is unknown,
- do nothing."""
- if not path.startswith('~'):
- return path
- i = path.find('/', 1)
- if i < 0:
- i = len(path)
- if i == 1:
- if 'HOME' not in os.environ:
- return path
- else:
- userhome = os.environ['HOME']
- else:
- # XXX: Jython lacks the pwd module: '~user' isn't supported
- return path
- userhome = userhome.rstrip('/')
- return userhome + path[i:]
-
-
-# Expand paths containing shell variable substitutions.
-# This expands the forms $variable and ${variable} only.
-# Non-existent variables are left unchanged.
-
-_varprog = None
-
-def expandvars(path):
- """Expand shell variables of form $var and ${var}. Unknown variables
- are left unchanged."""
- global _varprog
- if '$' not in path:
- return path
- if not _varprog:
- import re
- _varprog = re.compile(r'\$(\w+|\{[^}]*\})')
- i = 0
- while True:
- m = _varprog.search(path, i)
- if not m:
- break
- i, j = m.span(0)
- name = m.group(1)
- if name.startswith('{') and name.endswith('}'):
- name = name[1:-1]
- if name in os.environ:
- tail = path[j:]
- path = path[:i] + os.environ[name]
- i = len(path)
- path += tail
- else:
- i = j
- return path
-
-
-# Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A/B.
-# It should be understood that this may change the meaning of the path
-# if it contains symbolic links!
-
-def normpath(path):
- """Normalize path, eliminating double slashes, etc."""
- if path == '':
- return '.'
- initial_slashes = path.startswith('/')
- # POSIX allows one or two initial slashes, but treats three or more
- # as single slash.
- if (initial_slashes and
- path.startswith('//') and not path.startswith('///')):
- initial_slashes = 2
- comps = path.split('/')
- new_comps = []
- for comp in comps:
- if comp in ('', '.'):
- continue
- if (comp != '..' or (not initial_slashes and not new_comps) or
- (new_comps and new_comps[-1] == '..')):
- new_comps.append(comp)
- elif new_comps:
- new_comps.pop()
- comps = new_comps
- path = '/'.join(comps)
- if initial_slashes:
- path = '/'*initial_slashes + path
- return path or '.'
-
-
-def abspath(path):
- """Return an absolute path."""
- if not isabs(path):
- path = join(os.getcwd(), path)
- return normpath(path)
-
-
-# Return a canonical path (i.e. the absolute location of a file on the
-# filesystem).
-
-def realpath(filename):
- """Return the canonical path of the specified filename, eliminating any
-symbolic links encountered in the path."""
- if isabs(filename):
- bits = ['/'] + filename.split('/')[1:]
- else:
- bits = [''] + filename.split('/')
-
- for i in range(2, len(bits)+1):
- component = join(*bits[0:i])
- # Resolve symbolic links.
- if islink(component):
- resolved = _resolve_link(component)
- if resolved is None:
- # Infinite loop -- return original component + rest of the path
- return abspath(join(*([component] + bits[i:])))
- else:
- newpath = join(*([resolved] + bits[i:]))
- return realpath(newpath)
-
- return abspath(filename)
-
-
-if not os._native_posix:
- def _resolve_link(path):
- """Internal helper function. Takes a path and follows symlinks
- until we either arrive at something that isn't a symlink, or
- encounter a path we've seen before (meaning that there's a loop).
- """
- try:
- return newString(java.io.File(abspath(path)).getCanonicalPath())
- except java.io.IOException:
- return None
-else:
- def _resolve_link(path):
- """Internal helper function. Takes a path and follows symlinks
- until we either arrive at something that isn't a symlink, or
- encounter a path we've seen before (meaning that there's a loop).
- """
- paths_seen = []
- while islink(path):
- if path in paths_seen:
- # Already seen this path, so we must have a symlink loop
- return None
- paths_seen.append(path)
- # Resolve where the link points to
- resolved = os.readlink(path)
- if not isabs(resolved):
- dir = dirname(path)
- path = normpath(join(dir, resolved))
- else:
- path = normpath(resolved)
- return path
-
-def relpath(path, start=curdir):
- """Return a relative version of a path"""
-
- if not path:
- raise ValueError("no path specified")
-
- start_list = [x for x in abspath(start).split(sep) if x]
- path_list = [x for x in abspath(path).split(sep) if x]
-
- # Work out how much of the filepath is shared by start and path.
- i = len(commonprefix([start_list, path_list]))
-
- rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
- if not rel_list:
- return curdir
- return join(*rel_list)
-def _ensure_str(obj):
- """Ensure obj is a string, otherwise raise a TypeError"""
- if isinstance(obj, basestring):
- return obj
- raise TypeError('coercing to Unicode: need string or buffer, %s found' % \
- _type_name(obj))
-
-
-def _type_name(obj):
- """Determine the appropriate type name of obj for display"""
- TPFLAGS_HEAPTYPE = 1 << 9
- type_name = ''
- obj_type = type(obj)
- is_heap = obj_type.__flags__ & TPFLAGS_HEAPTYPE == TPFLAGS_HEAPTYPE
- if not is_heap and obj_type.__module__ != '__builtin__':
- type_name = '%s.' % obj_type.__module__
- type_name += obj_type.__name__
- return type_name
-
-supports_unicode_filenames = False
diff --git a/Lib/pwd.py b/Lib/pwd.py
--- a/Lib/pwd.py
+++ b/Lib/pwd.py
@@ -11,7 +11,7 @@
__all__ = ['getpwuid', 'getpwnam', 'getpwall']
from os import _name, _posix_impl
-from org.python.core.Py import newString
+from org.python.core.Py import newStringOrUnicode
import sys
if _name == 'nt':
@@ -30,9 +30,9 @@
'pw_dir', 'pw_shell']
def __new__(cls, pwd):
- pwd = (newString(pwd.loginName), newString(pwd.password), int(pwd.UID),
- int(pwd.GID), newString(pwd.GECOS), newString(pwd.home),
- newString(pwd.shell))
+ pwd = (newStringOrUnicode(pwd.loginName), newStringOrUnicode(pwd.password), int(pwd.UID),
+ int(pwd.GID), newStringOrUnicode(pwd.GECOS), newStringOrUnicode(pwd.home),
+ newStringOrUnicode(pwd.shell))
return tuple.__new__(cls, pwd)
def __getattr__(self, attr):
diff --git a/Lib/test/test_posixpath.py b/Lib/test/test_posixpath.py
deleted file mode 100644
--- a/Lib/test/test_posixpath.py
+++ /dev/null
@@ -1,521 +0,0 @@
-import unittest
-from test import test_support
-
-import posixpath, os
-from posixpath import realpath, abspath, join, dirname, basename
-
-# An absolute path to a temporary filename for testing. We can't rely on TESTFN
-# being an absolute path, so we need this.
-
-ABSTFN = abspath(test_support.TESTFN)
-
-class PosixPathTest(unittest.TestCase):
-
- def assertIs(self, a, b):
- self.assert_(a is b)
-
- def test_normcase(self):
- # Check that normcase() is idempotent
- p = "FoO/./BaR"
- p = posixpath.normcase(p)
- self.assertEqual(p, posixpath.normcase(p))
-
- self.assertRaises(TypeError, posixpath.normcase)
-
- def test_join(self):
- self.assertEqual(posixpath.join("/foo", "bar", "/bar", "baz"), "/bar/baz")
- self.assertEqual(posixpath.join("/foo", "bar", "baz"), "/foo/bar/baz")
- self.assertEqual(posixpath.join("/foo/", "bar/", "baz/"), "/foo/bar/baz/")
-
- self.assertRaises(TypeError, posixpath.join)
-
- def test_splitdrive(self):
- self.assertEqual(posixpath.splitdrive("/foo/bar"), ("", "/foo/bar"))
-
- self.assertRaises(TypeError, posixpath.splitdrive)
-
- def test_split(self):
- self.assertEqual(posixpath.split("/foo/bar"), ("/foo", "bar"))
- self.assertEqual(posixpath.split("/"), ("/", ""))
- self.assertEqual(posixpath.split("foo"), ("", "foo"))
- self.assertEqual(posixpath.split("////foo"), ("////", "foo"))
- self.assertEqual(posixpath.split("//foo//bar"), ("//foo", "bar"))
-
- self.assertRaises(TypeError, posixpath.split)
-
- def test_splitext(self):
- self.assertEqual(posixpath.splitext("foo.ext"), ("foo", ".ext"))
- self.assertEqual(posixpath.splitext("/foo/foo.ext"), ("/foo/foo", ".ext"))
- self.assertEqual(posixpath.splitext(".ext"), ("", ".ext"))
- self.assertEqual(posixpath.splitext("/foo.ext/foo"), ("/foo.ext/foo", ""))
- self.assertEqual(posixpath.splitext("foo.ext/"), ("foo.ext/", ""))
- self.assertEqual(posixpath.splitext(""), ("", ""))
- self.assertEqual(posixpath.splitext("foo.bar.ext"), ("foo.bar", ".ext"))
-
- self.assertRaises(TypeError, posixpath.splitext)
-
- def test_isabs(self):
- self.assertIs(posixpath.isabs(""), False)
- self.assertIs(posixpath.isabs("/"), True)
- self.assertIs(posixpath.isabs("/foo"), True)
- self.assertIs(posixpath.isabs("/foo/bar"), True)
- self.assertIs(posixpath.isabs("foo/bar"), False)
-
- self.assertRaises(TypeError, posixpath.isabs)
-
- def test_splitdrive(self):
- self.assertEqual(posixpath.splitdrive("/foo/bar"), ("", "/foo/bar"))
-
- self.assertRaises(TypeError, posixpath.splitdrive)
-
- def test_basename(self):
- self.assertEqual(posixpath.basename("/foo/bar"), "bar")
- self.assertEqual(posixpath.basename("/"), "")
- self.assertEqual(posixpath.basename("foo"), "foo")
- self.assertEqual(posixpath.basename("////foo"), "foo")
- self.assertEqual(posixpath.basename("//foo//bar"), "bar")
-
- self.assertRaises(TypeError, posixpath.basename)
-
- def test_dirname(self):
- self.assertEqual(posixpath.dirname("/foo/bar"), "/foo")
- self.assertEqual(posixpath.dirname("/"), "/")
- self.assertEqual(posixpath.dirname("foo"), "")
- self.assertEqual(posixpath.dirname("////foo"), "////")
- self.assertEqual(posixpath.dirname("//foo//bar"), "//foo")
-
- self.assertRaises(TypeError, posixpath.dirname)
-
- def test_commonprefix(self):
- self.assertEqual(
- posixpath.commonprefix([]),
- ""
- )
- self.assertEqual(
- posixpath.commonprefix(["/home/swenson/spam", "/home/swen/spam"]),
- "/home/swen"
- )
- self.assertEqual(
- posixpath.commonprefix(["/home/swen/spam", "/home/swen/eggs"]),
- "/home/swen/"
- )
- self.assertEqual(
- posixpath.commonprefix(["/home/swen/spam", "/home/swen/spam"]),
- "/home/swen/spam"
- )
-
- def test_getsize(self):
- f = open(test_support.TESTFN, "wb")
- try:
- f.write("foo")
- f.close()
- self.assertEqual(posixpath.getsize(test_support.TESTFN), 3)
- finally:
- if not f.closed:
- f.close()
- os.remove(test_support.TESTFN)
-
- def test_time(self):
- f = open(test_support.TESTFN, "wb")
- try:
- f.write("foo")
- f.close()
- f = open(test_support.TESTFN, "ab")
- f.write("bar")
- f.close()
- f = open(test_support.TESTFN, "rb")
- d = f.read()
- f.close()
- self.assertEqual(d, "foobar")
-
- self.assert_(
- posixpath.getctime(test_support.TESTFN) <=
- posixpath.getmtime(test_support.TESTFN)
- )
- finally:
- if not f.closed:
- f.close()
- os.remove(test_support.TESTFN)
-
- @unittest.skip("FIXME: broken")
- def test_islink(self):
- self.assertIs(posixpath.islink(test_support.TESTFN + "1"), False)
- f = open(test_support.TESTFN + "1", "wb")
- try:
- f.write("foo")
- f.close()
- self.assertIs(posixpath.islink(test_support.TESTFN + "1"), False)
- if hasattr(os, "symlink"):
- os.symlink(test_support.TESTFN + "1", test_support.TESTFN + "2")
- self.assertIs(posixpath.islink(test_support.TESTFN + "2"), True)
- os.remove(test_support.TESTFN + "1")
- self.assertIs(posixpath.islink(test_support.TESTFN + "2"), True)
- self.assertIs(posixpath.exists(test_support.TESTFN + "2"), False)
- self.assertIs(posixpath.lexists(test_support.TESTFN + "2"), True)
- finally:
- if not f.close():
- f.close()
- try:
- os.remove(test_support.TESTFN + "1")
- except os.error:
- pass
- try:
- os.remove(test_support.TESTFN + "2")
- except os.error:
- pass
-
- self.assertRaises(TypeError, posixpath.islink)
-
- def test_exists(self):
- self.assertIs(posixpath.exists(test_support.TESTFN), False)
- f = open(test_support.TESTFN, "wb")
- try:
- f.write("foo")
- f.close()
- self.assertIs(posixpath.exists(test_support.TESTFN), True)
- self.assertIs(posixpath.lexists(test_support.TESTFN), True)
- finally:
- if not f.close():
- f.close()
- try:
- os.remove(test_support.TESTFN)
- except os.error:
- pass
-
- self.assertRaises(TypeError, posixpath.exists)
-
- def test_isdir(self):
- self.assertIs(posixpath.isdir(test_support.TESTFN), False)
- f = open(test_support.TESTFN, "wb")
- try:
- f.write("foo")
- f.close()
- self.assertIs(posixpath.isdir(test_support.TESTFN), False)
- os.remove(test_support.TESTFN)
- os.mkdir(test_support.TESTFN)
- self.assertIs(posixpath.isdir(test_support.TESTFN), True)
- os.rmdir(test_support.TESTFN)
- finally:
- if not f.close():
- f.close()
- try:
- os.remove(test_support.TESTFN)
- except os.error:
- pass
- try:
- os.rmdir(test_support.TESTFN)
- except os.error:
- pass
-
- self.assertRaises(TypeError, posixpath.isdir)
-
- def test_isfile(self):
- self.assertIs(posixpath.isfile(test_support.TESTFN), False)
- f = open(test_support.TESTFN, "wb")
- try:
- f.write("foo")
- f.close()
- self.assertIs(posixpath.isfile(test_support.TESTFN), True)
- os.remove(test_support.TESTFN)
- os.mkdir(test_support.TESTFN)
- self.assertIs(posixpath.isfile(test_support.TESTFN), False)
- os.rmdir(test_support.TESTFN)
- finally:
- if not f.close():
- f.close()
- try:
- os.remove(test_support.TESTFN)
- except os.error:
- pass
- try:
- os.rmdir(test_support.TESTFN)
- except os.error:
- pass
-
- self.assertRaises(TypeError, posixpath.isdir)
-
- def test_samefile(self):
- f = open(test_support.TESTFN + "1", "wb")
- try:
- f.write("foo")
- f.close()
- self.assertIs(
- posixpath.samefile(
- test_support.TESTFN + "1",
- test_support.TESTFN + "1"
- ),
- True
- )
- # If we don't have links, assume that os.stat doesn't return resonable
- # inode information and thus, that samefile() doesn't work
- if hasattr(os, "symlink"):
- os.symlink(
- test_support.TESTFN + "1",
- test_support.TESTFN + "2"
- )
- self.assertIs(
- posixpath.samefile(
- test_support.TESTFN + "1",
- test_support.TESTFN + "2"
- ),
- True
- )
- os.remove(test_support.TESTFN + "2")
- f = open(test_support.TESTFN + "2", "wb")
- f.write("bar")
- f.close()
- self.assertIs(
- posixpath.samefile(
- test_support.TESTFN + "1",
- test_support.TESTFN + "2"
- ),
- False
- )
- finally:
- if not f.close():
- f.close()
- try:
- os.remove(test_support.TESTFN + "1")
- except os.error:
- pass
- try:
- os.remove(test_support.TESTFN + "2")
- except os.error:
- pass
-
- self.assertRaises(TypeError, posixpath.samefile)
-
- if os.name != 'java':
- def test_samestat(self):
- f = open(test_support.TESTFN + "1", "wb")
- try:
- f.write("foo")
- f.close()
- self.assertIs(
- posixpath.samestat(
- os.stat(test_support.TESTFN + "1"),
- os.stat(test_support.TESTFN + "1")
- ),
- True
- )
- # If we don't have links, assume that os.stat() doesn't return resonable
- # inode information and thus, that samefile() doesn't work
- if hasattr(os, "symlink"):
- if hasattr(os, "symlink"):
- os.symlink(test_support.TESTFN + "1", test_support.TESTFN + "2")
- self.assertIs(
- posixpath.samestat(
- os.stat(test_support.TESTFN + "1"),
- os.stat(test_support.TESTFN + "2")
- ),
- True
- )
- os.remove(test_support.TESTFN + "2")
- f = open(test_support.TESTFN + "2", "wb")
- f.write("bar")
- f.close()
- self.assertIs(
- posixpath.samestat(
- os.stat(test_support.TESTFN + "1"),
- os.stat(test_support.TESTFN + "2")
- ),
- False
- )
- finally:
- if not f.close():
- f.close()
- try:
- os.remove(test_support.TESTFN + "1")
- except os.error:
- pass
- try:
- os.remove(test_support.TESTFN + "2")
- except os.error:
- pass
-
- self.assertRaises(TypeError, posixpath.samestat)
-
- def test_ismount(self):
- self.assertIs(posixpath.ismount("/"), True)
-
- self.assertRaises(TypeError, posixpath.ismount)
-
- def test_expanduser(self):
- self.assertEqual(posixpath.expanduser("foo"), "foo")
- try:
- import pwd
- except ImportError:
- pass
- else:
- self.assert_(isinstance(posixpath.expanduser("~/"), basestring))
- # if home directory == root directory, this test makes no sense
- if posixpath.expanduser("~") != '/':
- self.assertEqual(
- posixpath.expanduser("~") + "/",
- posixpath.expanduser("~/")
- )
- self.assert_(isinstance(posixpath.expanduser("~root/"), basestring))
- self.assert_(isinstance(posixpath.expanduser("~foo/"), basestring))
-
- self.assertRaises(TypeError, posixpath.expanduser)
-
- def test_expandvars(self):
- oldenv = os.environ.copy()
- try:
- os.environ.clear()
- os.environ["foo"] = "bar"
- os.environ["{foo"] = "baz1"
- os.environ["{foo}"] = "baz2"
- self.assertEqual(posixpath.expandvars("foo"), "foo")
- self.assertEqual(posixpath.expandvars("$foo bar"), "bar bar")
- self.assertEqual(posixpath.expandvars("${foo}bar"), "barbar")
- self.assertEqual(posixpath.expandvars("$[foo]bar"), "$[foo]bar")
- self.assertEqual(posixpath.expandvars("$bar bar"), "$bar bar")
- self.assertEqual(posixpath.expandvars("$?bar"), "$?bar")
- self.assertEqual(posixpath.expandvars("${foo}bar"), "barbar")
- self.assertEqual(posixpath.expandvars("$foo}bar"), "bar}bar")
- self.assertEqual(posixpath.expandvars("${foo"), "${foo")
- self.assertEqual(posixpath.expandvars("${{foo}}"), "baz1}")
- finally:
- os.environ.clear()
- os.environ.update(oldenv)
-
- self.assertRaises(TypeError, posixpath.expandvars)
-
- def test_normpath(self):
- self.assertEqual(posixpath.normpath(""), ".")
- self.assertEqual(posixpath.normpath("/"), "/")
- self.assertEqual(posixpath.normpath("//"), "//")
- self.assertEqual(posixpath.normpath("///"), "/")
- self.assertEqual(posixpath.normpath("///foo/.//bar//"), "/foo/bar")
- self.assertEqual(posixpath.normpath("///foo/.//bar//.//..//.//baz"), "/foo/baz")
- self.assertEqual(posixpath.normpath("///..//./foo/.//bar"), "/foo/bar")
-
- self.assertRaises(TypeError, posixpath.normpath)
-
- def test_abspath(self):
- self.assert_("foo" in posixpath.abspath("foo"))
-
- self.assertRaises(TypeError, posixpath.abspath)
-
- def test_realpath(self):
- self.assert_("foo" in realpath("foo"))
- self.assertRaises(TypeError, posixpath.realpath)
-
- if hasattr(os, "symlink"):
- @unittest.skip("FIXME: broken")
- def test_realpath_basic(self):
- # Basic operation.
- try:
- os.symlink(ABSTFN+"1", ABSTFN)
- self.assertEqual(realpath(ABSTFN), ABSTFN+"1")
- finally:
- self.safe_remove(ABSTFN)
-
- def test_realpath_symlink_loops(self):
- # Bug #930024, return the path unchanged if we get into an infinite
- # symlink loop.
- try:
- old_path = abspath('.')
- os.symlink(ABSTFN, ABSTFN)
- self.assertEqual(realpath(ABSTFN), ABSTFN)
-
- os.symlink(ABSTFN+"1", ABSTFN+"2")
- os.symlink(ABSTFN+"2", ABSTFN+"1")
- self.assertEqual(realpath(ABSTFN+"1"), ABSTFN+"1")
- self.assertEqual(realpath(ABSTFN+"2"), ABSTFN+"2")
-
- # Test using relative path as well.
- os.chdir(dirname(ABSTFN))
- self.assertEqual(realpath(basename(ABSTFN)), ABSTFN)
- finally:
- os.chdir(old_path)
- self.safe_remove(ABSTFN)
- self.safe_remove(ABSTFN+"1")
- self.safe_remove(ABSTFN+"2")
-
- @unittest.skip("FIXME: broken")
- def test_realpath_resolve_parents(self):
- # We also need to resolve any symlinks in the parents of a relative
- # path passed to realpath. E.g.: current working directory is
- # /usr/doc with 'doc' being a symlink to /usr/share/doc. We call
- # realpath("a"). This should return /usr/share/doc/a/.
- try:
- old_path = abspath('.')
- os.mkdir(ABSTFN)
- os.mkdir(ABSTFN + "/y")
- os.symlink(ABSTFN + "/y", ABSTFN + "/k")
-
- os.chdir(ABSTFN + "/k")
- self.assertEqual(realpath("a"), ABSTFN + "/y/a")
- finally:
- os.chdir(old_path)
- self.safe_remove(ABSTFN + "/k")
- self.safe_rmdir(ABSTFN + "/y")
- self.safe_rmdir(ABSTFN)
-
- @unittest.skip("FIXME: broken")
- def test_realpath_resolve_before_normalizing(self):
- # Bug #990669: Symbolic links should be resolved before we
- # normalize the path. E.g.: if we have directories 'a', 'k' and 'y'
- # in the following hierarchy:
- # a/k/y
- #
- # and a symbolic link 'link-y' pointing to 'y' in directory 'a',
- # then realpath("link-y/..") should return 'k', not 'a'.
- try:
- old_path = abspath('.')
- os.mkdir(ABSTFN)
- os.mkdir(ABSTFN + "/k")
- os.mkdir(ABSTFN + "/k/y")
- os.symlink(ABSTFN + "/k/y", ABSTFN + "/link-y")
-
- # Absolute path.
- self.assertEqual(realpath(ABSTFN + "/link-y/.."), ABSTFN + "/k")
- # Relative path.
- os.chdir(dirname(ABSTFN))
- self.assertEqual(realpath(basename(ABSTFN) + "/link-y/.."), ABSTFN + "/k")
- finally:
- os.chdir(old_path)
- self.safe_remove(ABSTFN + "/link-y")
- self.safe_rmdir(ABSTFN + "/k/y")
- self.safe_rmdir(ABSTFN + "/k")
- self.safe_rmdir(ABSTFN)
-
- @unittest.skip("FIXME: broken")
- def test_realpath_resolve_first(self):
- # Bug #1213894: The first component of the path, if not absolute,
- # must be resolved too.
-
- try:
- old_path = abspath('.')
- os.mkdir(ABSTFN)
- os.mkdir(ABSTFN + "/k")
- os.symlink(ABSTFN, ABSTFN + "link")
- os.chdir(dirname(ABSTFN))
-
- base = basename(ABSTFN)
- self.assertEqual(realpath(base + "link"), ABSTFN)
- self.assertEqual(realpath(base + "link/k"), ABSTFN + "/k")
- finally:
- os.chdir(old_path)
- self.safe_remove(ABSTFN + "link")
- self.safe_rmdir(ABSTFN + "/k")
- self.safe_rmdir(ABSTFN)
-
- # Convenience functions for removing temporary files.
- def pass_os_error(self, func, filename):
- try: func(filename)
- except OSError: pass
-
- def safe_remove(self, filename):
- self.pass_os_error(os.remove, filename)
-
- def safe_rmdir(self, dirname):
- self.pass_os_error(os.rmdir, dirname)
-
-def test_main():
- test_support.run_unittest(PosixPathTest)
-
-if __name__=="__main__":
- test_main()
--
Repository URL: https://hg.python.org/jython
More information about the Jython-checkins
mailing list