Page MenuHomePhorge
Files F16571142

No OneTemporary
Actions

View Options

diff --git a/kdecore/tests/karchivetest.cpp b/kdecore/tests/karchivetest.cpp
index 1eb1dd2563..f754486b00 100644
--- a/kdecore/tests/karchivetest.cpp
+++ b/kdecore/tests/karchivetest.cpp
@@ -1,899 +1,890 @@
/* This file is part of the KDE project
Copyright (C) 2006, 2010 David Faure <faure@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include <config-compression.h>
#include "karchivetest.h"
#include <kmimetype.h>
#include "karchivetest.moc"
#include <ktar.h>
#include <kzip.h>
#include <qtest_kde.h>
#include <QtCore/QFileInfo>
#include <kdebug.h>
#include <kfilterdev.h>
#include <ktempdir.h>
#ifndef Q_OS_WIN
#include <unistd.h> // symlink
#include <errno.h>
#endif
QTEST_KDEMAIN_CORE( KArchiveTest )
static const int SIZE1 = 100;
/**
* Writes test fileset specified archive
* @param archive archive
*/
static void writeTestFilesToArchive( KArchive* archive )
{
QVERIFY( archive->writeFile( "empty", "weis", "users", "", 0 ) );
QVERIFY( archive->writeFile( "test1", "weis", "users", "Hallo", 5, 0100440 ) );
// Now let's try with the prepareWriting/writeData/finishWriting API
QVERIFY( archive->prepareWriting( "test2", "weis", "users", 8 ) );
QVERIFY( archive->writeData( "Hallo ", 6 ) );
QVERIFY( archive->writeData( "Du", 2 ) );
QVERIFY( archive->finishWriting( 8 ) );
// Add local file
QFile localFile( "test3" );
QVERIFY( localFile.open( QIODevice::WriteOnly ) );
QVERIFY( localFile.write( "Noch so einer", 13 ) == 13 );
localFile.close();
QVERIFY( archive->addLocalFile( "test3", "z/test3" ) );
// writeFile API
QVERIFY( archive->writeFile( "my/dir/test3", "dfaure", "hackers", "I do not speak German\nDavid.", 29 ) );
// Now a medium file : 100 null bytes
char medium[ SIZE1 ];
memset( medium, 0, SIZE1 );
QVERIFY( archive->writeFile( "mediumfile", "user", "group", medium, SIZE1 ) );
// Another one, with an absolute path
QVERIFY( archive->writeFile( "/dir/subdir/mediumfile2", "user", "group", medium, SIZE1 ) );
// Now a huge file : 20000 null bytes
int n = 20000;
char * huge = new char[ n ];
memset( huge, 0, n );
QVERIFY( archive->writeFile( "hugefile", "user", "group", huge, n ) );
delete [] huge;
// Now an empty directory
QVERIFY( archive->writeDir( "aaaemptydir", "user", "group" ) );
#ifndef Q_OS_WIN
// Add local symlink
QVERIFY( archive->addLocalFile( "test3_symlink", "z/test3_symlink") );
#endif
}
enum { WithUserGroup = 1 }; // ListingFlags
static QStringList recursiveListEntries( const KArchiveDirectory * dir, const QString & path, int listingFlags )
{
QStringList ret;
QStringList l = dir->entries();
l.sort();
Q_FOREACH(const QString& it, l) {
const KArchiveEntry* entry = dir->entry(it);
QString descr;
descr += QString("mode=") + QString::number( entry->permissions(), 8 ) + ' ';
if ( listingFlags & WithUserGroup )
{
descr += QString("user=") + entry->user() + ' ';
descr += QString("group=") + entry->group() + ' ';
}
descr += QString("path=") + path+(it) + ' ';
descr += QString("type=") + ( entry->isDirectory() ? "dir" : "file" );
if ( entry->isFile() )
descr += QString(" size=") + QString::number( static_cast<const KArchiveFile *>(entry)->size() );
if (!entry->symLinkTarget().isEmpty())
descr += QString(" symlink=") + entry->symLinkTarget();
// TODO add date and time
//kDebug() << descr;
ret.append( descr );
if (entry->isDirectory())
ret += recursiveListEntries( (KArchiveDirectory *)entry, path+it+'/', listingFlags );
}
return ret;
}
/**
* Verifies contents of specified archive against test fileset
* @param archive archive
*/
static void testFileData( KArchive* archive )
{
const KArchiveDirectory* dir = archive->directory();
const KArchiveEntry* e = dir->entry( "z/test3" );
QVERIFY( e );
QVERIFY( e->isFile() );
const KArchiveFile* f = static_cast<const KArchiveFile*>( e );
QByteArray arr( f->data() );
QCOMPARE( arr.size(), 13 );
QCOMPARE( arr, QByteArray( "Noch so einer" ) );
// Now test using createDevice()
QIODevice *dev = f->createDevice();
QByteArray contents = dev->readAll();
QCOMPARE( contents, arr );
delete dev;
dev = f->createDevice();
contents = dev->read(5); // test reading in two chunks
QCOMPARE(contents.size(), 5);
contents += dev->read(50);
QCOMPARE(contents.size(), 13);
QCOMPARE( QString::fromLatin1(contents), QString::fromLatin1(arr) );
delete dev;
e = dir->entry( "mediumfile" );
QVERIFY( e && e->isFile() );
f = (KArchiveFile*)e;
QCOMPARE( f->data().size(), SIZE1 );
e = dir->entry( "hugefile" );
QVERIFY( e && e->isFile() );
f = (KArchiveFile*)e;
QCOMPARE( f->data().size(), 20000 );
e = dir->entry( "aaaemptydir" );
QVERIFY( e && e->isDirectory() );
e = dir->entry( "my/dir/test3" );
QVERIFY( e && e->isFile() );
f = (KArchiveFile*)e;
dev = f->createDevice();
QByteArray firstLine = dev->readLine();
QCOMPARE(QString::fromLatin1(firstLine), QString::fromLatin1("I do not speak German\n"));
QByteArray secondLine = dev->read(100);
QCOMPARE(QString::fromLatin1(secondLine), QString::fromLatin1("David."));
delete dev;
#ifndef Q_OS_WIN
e = dir->entry( "z/test3_symlink" );
QVERIFY(e);
QVERIFY(e->isFile());
QCOMPARE(e->symLinkTarget(), QString("test3"));
#endif
// Test "./" prefix for KOffice (xlink:href="./ObjectReplacements/Object 1")
e = dir->entry( "./hugefile" );
QVERIFY( e && e->isFile() );
e = dir->entry( "./my/dir/test3" );
QVERIFY( e && e->isFile() );
// Test directory entries
e = dir->entry( "my" );
QVERIFY(e && e->isDirectory());
e = dir->entry( "my/" );
QVERIFY(e && e->isDirectory());
e = dir->entry( "./my/" );
QVERIFY(e && e->isDirectory());
}
static void testReadWrite( KArchive* archive )
{
QVERIFY(archive->writeFile("newfile", "dfaure", "users", "New File", 8, 0100440));
}
static void testCopyTo( KArchive* archive )
{
const KArchiveDirectory* dir = archive->directory();
KTempDir tmpDir;
const QString dirName = tmpDir.name();
dir->copyTo( dirName );
QVERIFY(QFile::exists(dirName+"dir"));
QVERIFY(QFileInfo(dirName+"dir").isDir());
QFileInfo fileInfo1(dirName+"dir/subdir/mediumfile2");
QVERIFY(fileInfo1.exists());
QVERIFY(fileInfo1.isFile());
QCOMPARE(fileInfo1.size(), Q_INT64_C(100));
QFileInfo fileInfo2(dirName+"hugefile");
QVERIFY(fileInfo2.exists());
QVERIFY(fileInfo2.isFile());
QCOMPARE(fileInfo2.size(), Q_INT64_C(20000));
QFileInfo fileInfo3(dirName+"mediumfile");
QVERIFY(fileInfo3.exists());
QVERIFY(fileInfo3.isFile());
QCOMPARE(fileInfo3.size(), Q_INT64_C(100));
QFileInfo fileInfo4(dirName+"my/dir/test3");
QVERIFY(fileInfo4.exists());
QVERIFY(fileInfo4.isFile());
QCOMPARE(fileInfo4.size(), Q_INT64_C(29));
#ifndef Q_OS_WIN
const QString fileName = dirName+"z/test3_symlink";
const QFileInfo fileInfo5(fileName);
QVERIFY(fileInfo5.exists());
QVERIFY(fileInfo5.isFile());
// Do not use fileInfo.readLink() for unix symlinks
// It returns the -full- path to the target, while we want the target string "as is".
QString symLinkTarget;
const QByteArray encodedFileName = QFile::encodeName(fileName);
QByteArray s;
#if defined(PATH_MAX)
s.resize(PATH_MAX+1);
#else
int path_max = pathconf(encodedFileName.data(), _PC_PATH_MAX);
if (path_max <= 0) {
path_max = 4096;
}
s.resize(path_max);
#endif
int len = readlink(encodedFileName.data(), s.data(), s.size() - 1);
if ( len >= 0 ) {
s[len] = '\0';
symLinkTarget = QFile::decodeName(s);
}
QCOMPARE(symLinkTarget, QString("test3"));
#endif
}
/**
* Prepares dataset for archive filter tests
*/
void KArchiveTest::setupData()
{
QTest::addColumn<QString>("fileName");
QTest::addColumn<QString>("mimeType");
QTest::newRow(".tar.gz") << "karchivetest.tar.gz" << "application/x-gzip";
#if HAVE_BZIP2_SUPPORT
QTest::newRow(".tar.bz2") << "karchivetest.tar.bz2" << "application/x-bzip";
#endif
#if HAVE_XZ_SUPPORT
QTest::newRow(".tar.lzma") << "karchivetest.tar.lzma" << "application/x-lzma";
QTest::newRow(".tar.xz") << "karchivetest.tar.xz" << "application/x-xz";
#endif
}
/**
* @see QTest::initTestCase()
*/
void KArchiveTest::initTestCase()
{
#ifndef Q_OS_WIN
// Prepare local symlink
QFile::remove("test3_symlink");
if (::symlink("test3", "test3_symlink") != 0) {
qDebug() << errno;
QVERIFY(false);
}
#endif
// For better benchmarks: initialize KMimeTypeFactory magic here
KMimeType::findByContent(QByteArray("hello"));
}
void KArchiveTest::testCreateTar_data()
{
QTest::addColumn<QString>("fileName");
QTest::newRow(".tar") << "karchivetest.tar";
}
/**
* @dataProvider testCreateTar_data
*/
void KArchiveTest::testCreateTar()
{
QFETCH(QString, fileName);
// With tempfile: 0.7-0.8 ms, 994236 instr. loads
// Without tempfile: 0.81 ms, 992541 instr. loads
// Note: use ./karchivetest 2>&1 | grep ms
// to avoid being slowed down by the kDebugs.
QBENCHMARK {
KTar tar(fileName);
QVERIFY(tar.open(QIODevice::WriteOnly));
writeTestFilesToArchive(&tar);
QVERIFY(tar.close());
QFileInfo fileInfo(QFile::encodeName(fileName));
QVERIFY(fileInfo.exists());
// We can't check for an exact size because of the addLocalFile, whose data is system-dependent
QVERIFY(fileInfo.size() > 450);
}
// NOTE The only .tar test, cleanup here
QFile::remove(fileName);
}
/**
* @dataProvider setupData
*/
void KArchiveTest::testCreateTarXXX()
{
QFETCH(QString, fileName);
// With tempfile: 1.3-1.7 ms, 2555089 instr. loads
// Without tempfile: 0.87 ms, 987915 instr. loads
QBENCHMARK {
KTar tar(fileName);
QVERIFY(tar.open(QIODevice::WriteOnly));
writeTestFilesToArchive(&tar);
QVERIFY(tar.close());
QFileInfo fileInfo(QFile::encodeName(fileName));
QVERIFY(fileInfo.exists());
// We can't check for an exact size because of the addLocalFile, whose data is system-dependent
QVERIFY(fileInfo.size() > 350);
}
}
/**
* @dataProvider setupData
*/
void KArchiveTest::testReadTar() // testCreateTarGz must have been run first.
{
QFETCH( QString, fileName );
// 1.6-1.7 ms per interaction, 2908428 instruction loads
// After the "no tempfile when writing fix" this went down
// to 0.9-1.0 ms, 1689059 instruction loads.
// I guess it finds the data in the kernel cache now that no KTempFile is
// used when writing.
QBENCHMARK {
KTar tar( fileName );
QVERIFY( tar.open( QIODevice::ReadOnly ) );
const KArchiveDirectory* dir = tar.directory();
QVERIFY( dir != 0 );
const QStringList listing = recursiveListEntries( dir, "", WithUserGroup );
QFileInfo localFileData("test3");
#ifndef Q_WS_WIN
QCOMPARE( listing.count(), 15 );
#else
QCOMPARE( listing.count(), 14 );
#endif
QCOMPARE( listing[ 0], QString("mode=40755 user=user group=group path=aaaemptydir type=dir") );
QCOMPARE( listing[ 1], QString("mode=40777 user=%1 group=%2 path=dir type=dir").arg(localFileData.owner()).arg(localFileData.group()) );
QCOMPARE( listing[ 2], QString("mode=40777 user=%1 group=%2 path=dir/subdir type=dir").arg(localFileData.owner()).arg(localFileData.group()) );
QCOMPARE( listing[ 3], QString("mode=100644 user=user group=group path=dir/subdir/mediumfile2 type=file size=100") );
QCOMPARE( listing[ 4], QString("mode=100644 user=weis group=users path=empty type=file size=0") );
QCOMPARE( listing[ 5], QString("mode=100644 user=user group=group path=hugefile type=file size=20000") );
QCOMPARE( listing[ 6], QString("mode=100644 user=user group=group path=mediumfile type=file size=100") );
QCOMPARE( listing[ 7], QString("mode=40777 user=%1 group=%2 path=my type=dir").arg(localFileData.owner()).arg(localFileData.group()) );
QCOMPARE( listing[ 8], QString("mode=40777 user=%1 group=%2 path=my/dir type=dir").arg(localFileData.owner()).arg(localFileData.group()) );
QCOMPARE( listing[ 9], QString("mode=100644 user=dfaure group=hackers path=my/dir/test3 type=file size=29") );
QCOMPARE( listing[10], QString("mode=100440 user=weis group=users path=test1 type=file size=5") );
QCOMPARE( listing[11], QString("mode=100644 user=weis group=users path=test2 type=file size=8") );
QCOMPARE( listing[12], QString("mode=40777 user=%1 group=%2 path=z type=dir").arg(localFileData.owner()).arg(localFileData.group()) );
// This one was added with addLocalFile, so ignore mode/user/group.
QString str = listing[13];
str.replace(QRegExp("mode.*path"), "path" );
QCOMPARE( str, QString("path=z/test3 type=file size=13") );
#ifndef Q_OS_WIN
str = listing[14];
str.replace(QRegExp("mode.*path"), "path" );
QCOMPARE( str, QString("path=z/test3_symlink type=file size=0 symlink=test3") );
#endif
QVERIFY( tar.close() );
}
}
/**
* This tests the decompression using kfilterdev, basically.
* To debug KTarPrivate::fillTempFile().
*
* @dataProvider setupData
*/
void KArchiveTest::testUncompress()
{
QFETCH(QString, fileName);
QFETCH(QString, mimeType);
// testCreateTar must have been run first.
QVERIFY(QFile::exists(fileName));
QIODevice *filterDev = KFilterDev::deviceForFile(fileName, mimeType, true);
QVERIFY(filterDev);
QByteArray buffer;
buffer.resize(8*1024);
kDebug() << "buffer.size()=" << buffer.size();
QVERIFY(filterDev->open(QIODevice::ReadOnly));
qint64 totalSize = 0;
qint64 len = -1;
while (!filterDev->atEnd() && len != 0) {
len = filterDev->read(buffer.data(), buffer.size());
QVERIFY(len >= 0);
totalSize += len;
// kDebug() << "read len=" << len << " totalSize=" << totalSize;
}
filterDev->close();
delete filterDev;
// kDebug() << "totalSize=" << totalSize;
QVERIFY(totalSize > 26000); // 27648 here when using gunzip
}
/**
* @dataProvider setupData
*/
void KArchiveTest::testTarFileData()
{
QFETCH(QString, fileName);
// testCreateTar must have been run first.
KTar tar(fileName);
QVERIFY(tar.open(QIODevice::ReadOnly));
testFileData(&tar);
QVERIFY(tar.close());
}
/**
* @dataProvider setupData
*/
void KArchiveTest::testTarCopyTo()
{
QFETCH(QString, fileName);
// testCreateTar must have been run first.
KTar tar(fileName);
QVERIFY(tar.open(QIODevice::ReadOnly));
testCopyTo(&tar);
QVERIFY(tar.close());
}
/**
* @dataProvider setupData
*/
void KArchiveTest::testTarReadWrite()
{
QFETCH(QString, fileName);
// testCreateTar must have been run first.
KTar tar(fileName);
QVERIFY(tar.open(QIODevice::ReadWrite));
testReadWrite(&tar);
testFileData(&tar);
QVERIFY(tar.close());
// Reopen it and check it
{
KTar tar(fileName);
QVERIFY(tar.open(QIODevice::ReadOnly));
testFileData( &tar );
const KArchiveDirectory* dir = tar.directory();
const KArchiveEntry* e = dir->entry("newfile");
QVERIFY(e && e->isFile());
const KArchiveFile* f = (KArchiveFile*)e;
QCOMPARE(f->data().size(), 8);
}
// NOTE This is the last test for this dataset. so cleanup here
QFile::remove(fileName);
}
void KArchiveTest::testTarMaxLength_data()
{
QTest::addColumn<QString>("fileName");
QTest::newRow("maxlength.tar.gz") << "karchivetest-maxlength.tar.gz";
}
/**
* @dataProvider testTarMaxLength_data
*/
void KArchiveTest::testTarMaxLength()
{
QFETCH( QString, fileName );
KTar tar( fileName );
QVERIFY( tar.open( QIODevice::WriteOnly ) );
// Generate long filenames of each possible length bigger than 98...
// Also exceed 512 byte block size limit to see how well the ././@LongLink
// implementation fares
for (int i = 98; i < 514 ; i++ )
{
QString str, num;
str.fill( 'a', i-10 );
num.setNum( i );
num = num.rightJustified( 10, '0' );
tar.writeFile( str+num, "testu", "testg", "hum", 3 );
}
// Result of this test : works perfectly now (failed at 482 formerly and
// before that at 154).
QVERIFY( tar.close() );
QVERIFY( tar.open( QIODevice::ReadOnly ) );
const KArchiveDirectory* dir = tar.directory();
QVERIFY( dir != 0 );
const QStringList listing = recursiveListEntries( dir, "", WithUserGroup );
QCOMPARE( listing[ 0], QString("mode=100644 user=testu group=testg path=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0000000098 type=file size=3") );
QCOMPARE( listing[ 3], QString("mode=100644 user=testu group=testg path=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0000000101 type=file size=3") );
QCOMPARE( listing[ 4], QString("mode=100644 user=testu group=testg path=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0000000102 type=file size=3") );
QCOMPARE( listing.count(), 416 );
QVERIFY( tar.close() );
// NOTE Cleanup here
QFile::remove( fileName );
}
void KArchiveTest::testTarGlobalHeader()
{
KTar tar( QString::fromLatin1(KDESRCDIR) + QLatin1String( "global_header_test.tar.bz2" ) );
QVERIFY( tar.open( QIODevice::ReadOnly ) );
const KArchiveDirectory* dir = tar.directory();
QVERIFY( dir != 0 );
const QStringList listing = recursiveListEntries( dir, "", WithUserGroup );
QCOMPARE( listing[ 0], QString("mode=40775 user=root group=root path=Test type=dir") );
QCOMPARE( listing[ 1], QString("mode=664 user=root group=root path=Test/test.txt type=file size=0") );
QCOMPARE( listing.count(), 2 );
QVERIFY( tar.close() );
}
void KArchiveTest::testTarPrefix()
{
KTar tar( QString::fromLatin1(KDESRCDIR) + QLatin1String( "tar_prefix_test.tar.bz2" ) );
QVERIFY( tar.open( QIODevice::ReadOnly ) );
const KArchiveDirectory* dir = tar.directory();
QVERIFY( dir != 0 );
const QStringList listing = recursiveListEntries( dir, "", WithUserGroup );
QCOMPARE( listing[ 0], QString("mode=40775 user=root group=root path=Test type=dir") );
QCOMPARE( listing[ 1], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7 type=dir") );
QCOMPARE( listing[ 2], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples type=dir") );
QCOMPARE( listing[ 3], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator type=dir") );
QCOMPARE( listing[ 4], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator/trolltech_original type=dir") );
QCOMPARE( listing[ 5], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator/trolltech_original/java type=dir") );
QCOMPARE( listing[ 6], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator/trolltech_original/java/com type=dir") );
QCOMPARE( listing[ 7], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator/trolltech_original/java/com/trolltech type=dir") );
QCOMPARE( listing[ 8], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator/trolltech_original/java/com/trolltech/examples type=dir") );
QCOMPARE( listing[ 9], QString("mode=664 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator/trolltech_original/java/com/trolltech/examples/GeneratorExample.html type=file size=43086") );
QCOMPARE( listing.count(), 10 );
QVERIFY( tar.close() );
}
void KArchiveTest::testTarDirectoryForgotten()
{
KTar tar( QString::fromLatin1(KDESRCDIR) + QLatin1String( "tar_directory_forgotten.tar.bz2" ) );
QVERIFY( tar.open( QIODevice::ReadOnly ) );
const KArchiveDirectory* dir = tar.directory();
QVERIFY( dir != 0 );
const QStringList listing = recursiveListEntries( dir, "", WithUserGroup );
- QCOMPARE( listing[ 0], QString("mode=40775 user=root group=root path=Test type=dir") );
- QCOMPARE( listing[ 1], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7 type=dir") );
- QCOMPARE( listing[ 2], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples type=dir") );
- QCOMPARE( listing[ 3], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator type=dir") );
- QCOMPARE( listing[ 4], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator/trolltech_original type=dir") );
- QCOMPARE( listing[ 5], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator/trolltech_original/java type=dir") );
- QCOMPARE( listing[ 6], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator/trolltech_original/java/com type=dir") );
- QCOMPARE( listing[ 7], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator/trolltech_original/java/com/trolltech type=dir") );
- QCOMPARE( listing[ 8], QString("mode=40775 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator/trolltech_original/java/com/trolltech/examples type=dir") );
- QCOMPARE( listing[ 9], QString("mode=40777 user=nef group=users path=Test/qt-jambi-qtjambi-4_7/examples/generator/trolltech_original/java/com/trolltech/examples/generator type=dir") );
- QCOMPARE( listing[ 10], QString("mode=664 user=root group=root path=Test/qt-jambi-qtjambi-4_7/examples/generator/trolltech_original/java/com/trolltech/examples/generator/GeneratorExample.html type=file size=43086") );
+ QVERIFY( listing[9].contains("trolltech/examples/generator") );
+ QVERIFY( listing[10].contains("trolltech/examples/generator/GeneratorExample.html") );
QCOMPARE( listing.count(), 11 );
QVERIFY( tar.close() );
}
///
static const char s_zipFileName[] = "karchivetest.zip";
static const char s_zipMaxLengthFileName[] = "karchivetest-maxlength.zip";
static const char s_zipLocaleFileName[] = "karchivetest-locale.zip";
static const char s_zipMimeType[] = "application/vnd.oasis.opendocument.text";
void KArchiveTest::testCreateZip()
{
KZip zip( s_zipFileName );
QVERIFY( zip.open( QIODevice::WriteOnly ) );
zip.setExtraField( KZip::NoExtraField );
zip.setCompression( KZip::NoCompression );
QByteArray zipMimeType( s_zipMimeType );
zip.writeFile( "mimetype", "", "", zipMimeType.data(), zipMimeType.size() );
zip.setCompression( KZip::DeflateCompression );
writeTestFilesToArchive( &zip );
QVERIFY( zip.close() );
QFile zipFile( QFile::encodeName( s_zipFileName ) );
QFileInfo fileInfo( zipFile );
QVERIFY( fileInfo.exists() );
QVERIFY( fileInfo.size() > 300 );
// Check that the header with no-compression and no-extrafield worked.
// (This is for the "magic" for koffice documents)
QVERIFY( zipFile.open( QIODevice::ReadOnly ) );
QByteArray arr = zipFile.read( 4 );
QCOMPARE( arr, QByteArray( "PK\003\004" ) );
QVERIFY( zipFile.seek( 30 ) );
arr = zipFile.read( 8 );
QCOMPARE( arr, QByteArray( "mimetype" ) );
arr = zipFile.read( zipMimeType.size() );
QCOMPARE( arr, zipMimeType );
}
void KArchiveTest::testCreateZipError()
{
// Giving a directory name to kzip must give an error case in close(), see #136630.
// Otherwise we just lose data.
KZip zip(QDir::currentPath());
QVERIFY(zip.open(QIODevice::WriteOnly));
writeTestFilesToArchive(&zip);
// try to add something as a file that is no file
QVERIFY( !zip.addLocalFile( QDir::currentPath(), "bogusdir" ) );
QVERIFY(!zip.close());
}
void KArchiveTest::testReadZipError()
{
QFile brokenZip( "broken.zip" );
QVERIFY( brokenZip.open( QIODevice::WriteOnly ) );
// incomplete magic
brokenZip.write( QByteArray( "PK\003" ) );
brokenZip.close();
KZip zip( "broken.zip" );
QVERIFY( !zip.open(QIODevice::ReadOnly) );
QVERIFY( brokenZip.open( QIODevice::WriteOnly | QIODevice::Append ) );
// add rest of magic, but still incomplete header
brokenZip.write( QByteArray( "\004\000\000\000\000" ) );
brokenZip.close();
QVERIFY( !zip.open(QIODevice::ReadOnly) );
QVERIFY( brokenZip.remove() );
}
void KArchiveTest::testReadZip()
{
// testCreateZip must have been run first.
KZip zip( s_zipFileName );
QVERIFY( zip.open( QIODevice::ReadOnly ) );
const KArchiveDirectory* dir = zip.directory();
QVERIFY( dir != 0 );
// ZIP has no support for per-file user/group, so omit them from the listing
const QStringList listing = recursiveListEntries( dir, "", 0 );
#ifndef Q_WS_WIN
QCOMPARE( listing.count(), 16 );
#else
QCOMPARE( listing.count(), 15 );
#endif
QCOMPARE( listing[ 0], QString("mode=40755 path=aaaemptydir type=dir") );
QCOMPARE( listing[ 1], QString("mode=40777 path=dir type=dir") );
QCOMPARE( listing[ 2], QString("mode=40777 path=dir/subdir type=dir") );
QCOMPARE( listing[ 3], QString("mode=100644 path=dir/subdir/mediumfile2 type=file size=100") );
QCOMPARE( listing[ 4], QString("mode=100644 path=empty type=file size=0") );
QCOMPARE( listing[ 5], QString("mode=100644 path=hugefile type=file size=20000") );
QCOMPARE( listing[ 6], QString("mode=100644 path=mediumfile type=file size=100") );
QCOMPARE( listing[ 7], QString("mode=100644 path=mimetype type=file size=%1").arg(strlen(s_zipMimeType)) );
QCOMPARE( listing[ 8], QString("mode=40777 path=my type=dir") );
QCOMPARE( listing[ 9], QString("mode=40777 path=my/dir type=dir") );
QCOMPARE( listing[10], QString("mode=100644 path=my/dir/test3 type=file size=29") );
QCOMPARE( listing[11], QString("mode=100440 path=test1 type=file size=5") );
QCOMPARE( listing[12], QString("mode=100644 path=test2 type=file size=8") );
QCOMPARE( listing[13], QString("mode=40777 path=z type=dir") );
// This one was added with addLocalFile, so ignore mode
QString str = listing[14];
str.replace(QRegExp("mode.*path"), "path" );
QCOMPARE( str, QString("path=z/test3 type=file size=13") );
#ifndef Q_OS_WIN
str = listing[15];
str.replace(QRegExp("mode.*path"), "path" );
QCOMPARE( str, QString("path=z/test3_symlink type=file size=5 symlink=test3") );
#endif
QVERIFY( zip.close() );
}
void KArchiveTest::testZipFileData()
{
// testCreateZip must have been run first.
KZip zip(s_zipFileName);
QVERIFY(zip.open( QIODevice::ReadOnly));
testFileData(&zip);
QVERIFY(zip.close());
}
void KArchiveTest::testZipCopyTo()
{
// testCreateZip must have been run first.
KZip zip(s_zipFileName);
QVERIFY(zip.open(QIODevice::ReadOnly));
testCopyTo(&zip);
QVERIFY(zip.close());
}
void KArchiveTest::testZipMaxLength()
{
KZip zip( s_zipMaxLengthFileName );
QVERIFY( zip.open( QIODevice::WriteOnly ) );
// Similar to testTarMaxLength just to make sure, but of course zip doesn't have
// those limitations in the first place.
for (int i = 98; i < 514 ; i++ )
{
QString str, num;
str.fill( 'a', i-10 );
num.setNum( i );
num = num.rightJustified( 10, '0' );
zip.writeFile( str+num, "testu", "testg", "hum", 3 );
}
QVERIFY( zip.close() );
QVERIFY( zip.open( QIODevice::ReadOnly ) );
const KArchiveDirectory* dir = zip.directory();
QVERIFY( dir != 0 );
const QStringList listing = recursiveListEntries( dir, "", 0 );
QCOMPARE( listing[ 0], QString("mode=100644 path=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0000000098 type=file size=3") );
QCOMPARE( listing[ 3], QString("mode=100644 path=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0000000101 type=file size=3") );
QCOMPARE( listing[ 4], QString("mode=100644 path=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0000000102 type=file size=3") );
QCOMPARE( listing.count(), 514 - 98 );
QVERIFY( zip.close() );
}
void KArchiveTest::testZipWithNonLatinFileNames()
{
KZip zip( s_zipLocaleFileName );
QVERIFY( zip.open( QIODevice::WriteOnly ) );
const QByteArray fileData("Test of data with a russian file name");
const QString fileName = QString::fromUtf8( "Архитектура.okular" );
const QString recodedFileName = QFile::decodeName( QFile::encodeName( fileName ) );
QVERIFY( zip.writeFile( fileName, "pino", "users", fileData.constData(), fileData.size() ) );
QVERIFY( zip.close() );
QVERIFY( zip.open( QIODevice::ReadOnly ) );
const KArchiveDirectory* dir = zip.directory();
QVERIFY( dir != 0 );
const QStringList listing = recursiveListEntries( dir, "", 0 );
QCOMPARE( listing.count(), 1 );
QCOMPARE( listing[0], QString::fromUtf8("mode=100644 path=%1 type=file size=%2").arg(recodedFileName).arg(fileData.size()) );
const KArchiveFile* fileEntry = static_cast< const KArchiveFile* >( dir->entry( dir->entries()[0] ) );
QCOMPARE( fileEntry->data(), fileData );
}
static bool writeFile(const QString& dirName, const QString& fileName, const QByteArray& data)
{
Q_ASSERT(dirName.endsWith('/'));
QFile file(dirName + fileName);
if (!file.open(QIODevice::WriteOnly))
return false;
file.write(data);
return true;
}
void KArchiveTest::testZipAddLocalDirectory()
{
// Prepare local dir
KTempDir tmpDir;
const QString dirName = tmpDir.name();
const QByteArray file1Data = "Hello Shantanu";
const QString file1 = QLatin1String("file1");
QVERIFY(writeFile(dirName, file1, file1Data));
{
KZip zip(s_zipFileName);
QVERIFY(zip.open(QIODevice::WriteOnly));
QVERIFY(zip.addLocalDirectory(dirName, "."));
QVERIFY(zip.close());
}
{
KZip zip(s_zipFileName);
QVERIFY(zip.open(QIODevice::ReadOnly));
const KArchiveDirectory* dir = zip.directory();
QVERIFY(dir != 0);
const KArchiveEntry* e = dir->entry(file1);
QVERIFY(e && e->isFile());
const KArchiveFile* f = (KArchiveFile*)e;
QCOMPARE(f->data(), file1Data);
}
}
/**
* @see QTest::cleanupTestCase()
*/
void KArchiveTest::cleanupTestCase()
{
QFile::remove(s_zipMaxLengthFileName);
QFile::remove(s_zipFileName);
QFile::remove(s_zipLocaleFileName);
#ifndef Q_OS_WIN
QFile::remove("test3_symlink");
#endif
}

File Metadata

Mime Type
text/x-diff
Expires
Fri, Nov 1, 9:59 AM (1 d, 19 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
10076259
Default Alt Text
(31 KB)

Event Timeline