from test
import test_support
# Check for our compression modules.
except (ImportError, AttributeError):
return test_support
.findfile(path
)
testtar
= path("testtar.tar")
tempdir
= os
.path
.join(tempfile
.gettempdir(), "testtar" + os
.extsep
+ "dir")
tempname
= test_support
.TESTFN
return os
.path
.join(tempdir
, "%s%s%s" % (testtar
, os
.extsep
, comp
))
if not os
.path
.exists(tempdir
):
class BaseTest(unittest
.TestCase
):
mode
= self
.mode
+ self
.sep
+ self
.comp
self
.tar
= tarfile
.open(tarname(self
.comp
), mode
)
class ReadTest(BaseTest
):
"""Test member extraction.
f
= self
.tar
.extractfile(tarinfo
)
self
.assert_(len(f
.read()) == tarinfo
.size
,
"size read does not match expected size")
self
.assert_(members
== membercount
,
"could not find all members")
"""Test sparse member extraction.
f1
= self
.tar
.extractfile("S-SPARSE")
f2
= self
.tar
.extractfile("S-SPARSE-WITH-NULLS")
self
.assert_(f1
.read() == f2
.read(),
"_FileObject failed on sparse file member")
def test_readlines(self
):
"""Test readlines() method of _FileObject.
filename
= "0-REGTYPE-TEXT"
self
.tar
.extract(filename
, dirname())
lines1
= file(os
.path
.join(dirname(), filename
), "rU").readlines()
lines2
= self
.tar
.extractfile(filename
).readlines()
self
.assert_(lines1
== lines2
,
"_FileObject.readline() does not work correctly")
"""Test seek() method of _FileObject, incl. random reading.
self
.tar
.extract(filename
, dirname())
data
= file(os
.path
.join(dirname(), filename
), "rb").read()
tarinfo
= self
.tar
.getmember(filename
)
fobj
= self
.tar
.extractfile(tarinfo
)
self
.assert_(0 == fobj
.tell(),
"seek() to file's start failed")
self
.assert_(2048 == fobj
.tell(),
"seek() to absolute position failed")
self
.assert_(1024 == fobj
.tell(),
"seek() to negative relative position failed")
self
.assert_(2048 == fobj
.tell(),
"seek() to positive relative position failed")
self
.assert_(s
== data
[2048:2058],
"read() after seek failed")
self
.assert_(tarinfo
.size
== fobj
.tell(),
"seek() to file's end failed")
self
.assert_(fobj
.read() == "",
"read() at file's end did not return empty string")
fobj
.seek(-tarinfo
.size
, 2)
self
.assert_(0 == fobj
.tell(),
"relative seek() to file's start failed")
"readlines() after seek failed")
class ReadStreamTest(ReadTest
):
"""Test member extraction, and for StreamError when
tarinfo
= self
.tar
.getmembers()[0]
f
= self
.tar
.extractfile(tarinfo
)
self
.assertRaises(tarfile
.StreamError
, f
.read
)
"""Compare the normal tar and the stream tar.
tar
= tarfile
.open(tarname(), 'r')
self
.assert_(t2
is not None, "stream.next() failed.")
if t2
.islnk() or t2
.issym():
self
.assertRaises(tarfile
.StreamError
, stream
.extractfile
, t2
)
v2
= stream
.extractfile(t2
)
self
.assert_(v2
is not None, "stream.extractfile() failed")
self
.assert_(v1
.read() == v2
.read(), "stream extraction failed")
class WriteTest(BaseTest
):
mode
= self
.mode
+ self
.sep
+ self
.comp
self
.src
= tarfile
.open(tarname(self
.comp
), 'r')
self
.dst
= tarfile
.open(self
.dstname
, mode
)
self
.dst
.add(os
.path
.join(os
.path
.dirname(__file__
),"cfgparser.1"))
self
.assertNotEqual(os
.stat(self
.dstname
).st_size
, 0)
f
= self
.src
.extractfile(tarinfo
)
if self
.dst
.posix
and len(tarinfo
.name
) > tarfile
.LENGTH_NAME
:
self
.assertRaises(ValueError, self
.dst
.addfile
,
self
.dst
.addfile(tarinfo
, f
)
class WriteSize0Test(BaseTest
):
self
.dst
= tarfile
.open(self
.dstname
, "w")
path
= os
.path
.join(self
.tmpdir
, "file")
tarinfo
= self
.dst
.gettarinfo(path
)
self
.assertEqual(tarinfo
.size
, 0)
file(path
, "w").write("aaa")
tarinfo
= self
.dst
.gettarinfo(path
)
self
.assertEqual(tarinfo
.size
, 3)
def test_directory(self
):
path
= os
.path
.join(self
.tmpdir
, "directory")
tarinfo
= self
.dst
.gettarinfo(path
)
self
.assertEqual(tarinfo
.size
, 0)
if hasattr(os
, "symlink"):
path
= os
.path
.join(self
.tmpdir
, "symlink")
os
.symlink("link_target", path
)
tarinfo
= self
.dst
.gettarinfo(path
)
self
.assertEqual(tarinfo
.size
, 0)
class WriteStreamTest(WriteTest
):
class WriteGNULongTest(unittest
.TestCase
):
"""This testcase checks for correct creation of GNU Longname
It creates a tarfile and adds empty members with either
long names, long linknames or both and compares the size
of the tarfile with the expected size.
It checks for SF bug #812325 in TarFile._create_gnulong().
While I was writing this testcase, I noticed a second bug
Long{names,links} weren't null-terminated which lead to
bad tarfiles when their length was a multiple of 512. This
self
.tar
= tarfile
.open(tmpname(), "w")
blocks
, remainder
= divmod(len(s
) + 1, 512)
def _calc_size(self
, name
, link
=None):
if len(name
) > tarfile
.LENGTH_NAME
:
# gnu longname extended header + longname
count
+= self
._length
(name
)
if link
is not None and len(link
) > tarfile
.LENGTH_LINK
:
# gnu longlink extended header + longlink
count
+= self
._length
(link
)
def _test(self
, name
, link
=None):
tarinfo
= tarfile
.TarInfo(name
)
tarinfo
.type = tarfile
.LNKTYPE
self
.tar
.addfile(tarinfo
)
v1
= self
._calc
_size
(name
, link
)
self
.assertEqual(v1
, v2
, "GNU longname/longlink creation failed")
def test_longname_1023(self
):
self
._test
(("longnam/" * 127) + "longnam")
def test_longname_1024(self
):
self
._test
(("longnam/" * 127) + "longname")
def test_longname_1025(self
):
self
._test
(("longnam/" * 127) + "longname_")
def test_longlink_1023(self
):
self
._test
("name", ("longlnk/" * 127) + "longlnk")
def test_longlink_1024(self
):
self
._test
("name", ("longlnk/" * 127) + "longlink")
def test_longlink_1025(self
):
self
._test
("name", ("longlnk/" * 127) + "longlink_")
def test_longnamelink_1023(self
):
self
._test
(("longnam/" * 127) + "longnam",
("longlnk/" * 127) + "longlnk")
def test_longnamelink_1024(self
):
self
._test
(("longnam/" * 127) + "longname",
("longlnk/" * 127) + "longlink")
def test_longnamelink_1025(self
):
self
._test
(("longnam/" * 127) + "longname_",
("longlnk/" * 127) + "longlink_")
class ExtractHardlinkTest(BaseTest
):
"""Test hardlink extraction (bug #857297)
# Prevent errors from being caught
self
.tar
.extract("0-REGTYPE", dirname())
# Extract 1-LNKTYPE which is a hardlink to 0-REGTYPE
self
.tar
.extract("1-LNKTYPE", dirname())
except EnvironmentError, e
:
if e
.errno
== errno
.ENOENT
:
self
.fail("hardlink not extracted properly")
class ReadTestGzip(ReadTest
):
class ReadStreamTestGzip(ReadStreamTest
):
class WriteTestGzip(WriteTest
):
class WriteStreamTestGzip(WriteStreamTest
):
class FileModeTest(unittest
.TestCase
):
self
.assertEqual(tarfile
.filemode(0755), '-rwxr-xr-x')
self
.assertEqual(tarfile
.filemode(07111), '---s--s--t')
class ReadTestBzip2(ReadTestGzip
):
class ReadStreamTestBzip2(ReadStreamTestGzip
):
class WriteTestBzip2(WriteTest
):
class WriteStreamTestBzip2(WriteStreamTestGzip
):
# If importing gzip failed, discard the Gzip TestCases.
gzip
.open(tarname("gz"), "wb").write(file(tarname(), "rb").read())
bz2
.BZ2File(tarname("bz2"), "wb").write(file(tarname(), "rb").read())
tests
.append(ExtractHardlinkTest
)
ReadTestGzip
, ReadStreamTestGzip
,
WriteTestGzip
, WriteStreamTestGzip
ReadTestBzip2
, ReadStreamTestBzip2
,
WriteTestBzip2
, WriteStreamTestBzip2
test_support
.run_unittest(*tests
)
os
.remove(tarname("bz2"))
if os
.path
.exists(dirname()):
if os
.path
.exists(tmpname()):
if __name__
== "__main__":