void TestQuaZipFile::zipUnzip()
{
QFETCH(QString, zipName);
QFETCH(QStringList, fileNames);
QFETCH(QByteArray, fileNameCodec);
QFETCH(QByteArray, password);
QFETCH(bool, zip64);
QFile testFile(zipName);
if (testFile.exists()) {
if (!testFile.remove()) {
QFAIL("Couldn't remove existing archive to create a new one");
}
}
if (!createTestFiles(fileNames)) {
QFAIL("Couldn't create test files for zipping");
}
QuaZip testZip(&testFile);
testZip.setZip64Enabled(zip64);
if (!fileNameCodec.isEmpty())
testZip.setFileNameCodec(fileNameCodec);
QVERIFY(testZip.open(QuaZip::mdCreate));
QString comment = "Test comment";
testZip.setComment(comment);
foreach (QString fileName, fileNames) {
QFile inFile("tmp/" + fileName);
if (!inFile.open(QIODevice::ReadOnly)) {
qDebug("File name: %s", fileName.toUtf8().constData());
QFAIL("Couldn't open input file");
}
QuaZipFile outFile(&testZip);
QVERIFY(outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(fileName,
inFile.fileName()),
password.isEmpty() ? NULL : password.constData()));
for (qint64 pos = 0, len = inFile.size(); pos < len; ) {
char buf[4096];
qint64 readSize = qMin(static_cast<qint64>(4096), len - pos);
qint64 l;
if ((l = inFile.read(buf, readSize)) != readSize) {
qDebug("Reading %ld bytes from %s at %ld returned %ld",
static_cast<long>(readSize),
fileName.toUtf8().constData(),
static_cast<long>(pos),
static_cast<long>(l));
QFAIL("Read failure");
}
QVERIFY(outFile.write(buf, readSize));
pos += readSize;
}
inFile.close();
outFile.close();
QCOMPARE(outFile.getZipError(), ZIP_OK);
}
void TestQuaZipDir::cd()
{
QFETCH(QString, zipName);
QFETCH(QStringList, fileNames);
QFETCH(QString, dirName);
QFETCH(QString, targetDirName);
QFETCH(QString, result);
QDir curDir;
if (!createTestFiles(fileNames)) {
QFAIL("Couldn't create test files");
}
if (!createTestArchive(zipName, fileNames)) {
QFAIL("Couldn't create test archive");
}
removeTestFiles(fileNames);
QuaZip zip(zipName);
QVERIFY(zip.open(QuaZip::mdUnzip));
QuaZipDir dir(&zip, dirName);
if (dirName.startsWith('/')) {
dirName = dirName.mid(1);
}
if (dirName.endsWith('/')) {
dirName.chop(1);
}
QCOMPARE(dir.path(), dirName);
{
int lastSlash = dirName.lastIndexOf('/');
if (lastSlash == -1) {
// dirName is just a single name
if (dirName.isEmpty()) {
QCOMPARE(dir.dirName(), QString::fromLatin1("."));
} else {
QCOMPARE(dir.dirName(), dirName);
}
} else {
// dirName is a sequence
QCOMPARE(dir.dirName(), dirName.mid(lastSlash + 1));
}
}
if (targetDirName == "..") {
QVERIFY(dir.cdUp());
} else {
QVERIFY(dir.cd(targetDirName));
}
QCOMPARE(dir.path(), result);
// Try to go back
dir.setPath(dirName);
QCOMPARE(dir.path(), dirName);
zip.close();
curDir.remove(zipName);
}
void TestQuaZipDir::entryList()
{
QFETCH(QString, zipName);
QFETCH(QStringList, fileNames);
QFETCH(QString, dirName);
QFETCH(QStringList, nameFilters);
QFETCH(int, filter);
QFETCH(int, sort);
QDir::Filters filters = static_cast<QDir::Filters>(filter);
QDir::SortFlags sorting = static_cast<QDir::SortFlags>(sort);
QFETCH(QStringList, entries);
QFETCH(int, caseSensitivity);
QDir curDir;
if (!createTestFiles(fileNames)) {
QFAIL("Couldn't create test files");
}
if (!createTestArchive(zipName, fileNames)) {
QFAIL("Couldn't create test archive");
}
removeTestFiles(fileNames);
QuaZip zip(zipName);
QVERIFY(zip.open(QuaZip::mdUnzip));
QuaZipDir dir(&zip, dirName);
QVERIFY(dir.exists());
if (caseSensitivity != -1) {
dir.setCaseSensitivity(static_cast<QuaZip::CaseSensitivity>(
caseSensitivity));
QCOMPARE(dir.caseSensitivity(), static_cast<QuaZip::CaseSensitivity>(
caseSensitivity));
}
QCOMPARE(dir.entryList(nameFilters, filters, sorting), entries);
// Test default sorting setting.
dir.setSorting(sorting);
QCOMPARE(dir.sorting(), sorting);
QCOMPARE(dir.entryList(nameFilters, filters), entries);
// Test default name filter setting.
dir.setNameFilters(nameFilters);
QCOMPARE(dir.nameFilters(), nameFilters);
QCOMPARE(dir.entryList(filters), entries);
// Test default filters.
dir.setFilter(filters);
QCOMPARE(dir.filter(), filters);
QCOMPARE(dir.entryList(), entries);
QCOMPARE(dir.entryList().count(), static_cast<int>(dir.count()));
zip.close();
curDir.remove(zipName);
}
void TestJlCompress::compressFiles()
{
QFETCH(QString, zipName);
QFETCH(QStringList, fileNames);
QDir curDir;
if (curDir.exists(zipName)) {
if (!curDir.remove(zipName))
QFAIL("Can't remove zip file");
}
if (!createTestFiles(fileNames)) {
QFAIL("Can't create test files");
}
QStringList realNamesList, shortNamesList;
foreach (QString fileName, fileNames) {
QString realName = "tmp/" + fileName;
realNamesList += realName;
shortNamesList += QFileInfo(realName).fileName();
}
void TestJlCompress::compressFile()
{
QFETCH(QString, zipName);
QFETCH(QString, fileName);
QDir curDir;
if (curDir.exists(zipName)) {
if (!curDir.remove(zipName))
QFAIL("Can't remove zip file");
}
if (!createTestFiles(QStringList() << fileName)) {
QFAIL("Can't create test file");
}
QVERIFY(JlCompress::compressFile(zipName, "tmp/" + fileName));
// get the file list and check it
QStringList fileList = JlCompress::getFileList(zipName);
QCOMPARE(fileList.count(), 1);
QVERIFY(fileList[0] == fileName);
removeTestFiles(QStringList() << fileName);
curDir.remove(zipName);
}
void TestQuaZipDir::entryInfoList()
{
QString zipName = "entryInfoList.zip";
QStringList fileNames;
fileNames << "test.txt";
if (!createTestFiles(fileNames)) {
QFAIL("Couldn't create test files");
}
if (!createTestArchive(zipName, fileNames)) {
QFAIL("Couldn't create test archive");
}
removeTestFiles(fileNames);
QuaZip zip(zipName);
QDir curDir;
QVERIFY(zip.open(QuaZip::mdUnzip));
QuaZipDir dir(&zip, "/");
QCOMPARE(dir.entryInfoList().size(), 1);
QCOMPARE(dir.entryInfoList64().size(), 1);
zip.close();
curDir.remove(zipName);
}
void TestQuaZipDir::cd()
{
QFETCH(QString, zipName);
QFETCH(QStringList, fileNames);
QFETCH(QString, dirName);
QFETCH(QString, targetDirName);
QFETCH(QString, result);
QDir curDir;
if (!createTestFiles(fileNames)) {
QFAIL("Couldn't create test files");
}
if (!createTestArchive(zipName, fileNames)) {
QFAIL("Couldn't create test archive");
}
removeTestFiles(fileNames);
QuaZip zip(zipName);
QVERIFY(zip.open(QuaZip::mdUnzip));
QuaZipDir dir(&zip, dirName);
QVERIFY(dir.cd(targetDirName));
QCOMPARE(dir.path(), result);
zip.close();
curDir.remove(zipName);
}
void TestQuaZipDir::filePath()
{
QString zipName = "entryInfoList.zip";
QStringList fileNames;
fileNames << "root.txt" << "dir/test.txt";
if (!createTestFiles(fileNames)) {
QFAIL("Couldn't create test files");
}
if (!createTestArchive(zipName, fileNames)) {
QFAIL("Couldn't create test archive");
}
removeTestFiles(fileNames);
QuaZip zip(zipName);
QDir curDir;
QVERIFY(zip.open(QuaZip::mdUnzip));
QuaZipDir dir(&zip);
QVERIFY(dir.cd("dir"));
QCOMPARE(dir.relativeFilePath("/root.txt"),
QString::fromLatin1("../root.txt"));
QCOMPARE(dir.filePath("test.txt"),
QString::fromLatin1("dir/test.txt"));
zip.close();
curDir.remove(zipName);
}
void TestQuaZipNewInfo::setFileNTFSTimes()
{
QString zipName = "newtimes.zip";
QStringList testFiles;
testFiles << "test.txt";
QDir curDir;
if (curDir.exists(zipName)) {
if (!curDir.remove(zipName))
QFAIL("Can't remove zip file");
}
if (!createTestFiles(testFiles)) {
QFAIL("Can't create test file");
}
QDateTime base(QDate(1601, 1, 1), QTime(0, 0), Qt::UTC);
quint64 mTicks, aTicks, cTicks;
{
// create
QuaZip zip(zipName);
QVERIFY(zip.open(QuaZip::mdCreate));
QuaZipFile zipFile(&zip);
QFileInfo fileInfo("tmp/test.txt");
mTicks = base.msecsTo(fileInfo.lastModified()) * 10000;
aTicks = base.msecsTo(fileInfo.lastRead()) * 10000;
cTicks = base.msecsTo(fileInfo.created()) * 10000;
QuaZipNewInfo newInfo("test.txt", "tmp/test.txt");
newInfo.setFileNTFSTimes("tmp/test.txt");
QVERIFY(zipFile.open(QIODevice::WriteOnly, newInfo));
zipFile.close();
zip.close();
}
{
// check
QuaZip zip(zipName);
QVERIFY(zip.open(QuaZip::mdUnzip));
zip.goToFirstFile();
QuaZipFileInfo64 fileInfo;
QVERIFY(zip.getCurrentFileInfo(&fileInfo));
zip.close();
QByteArray &extra = fileInfo.extra;
bool ntfsFound = false;
int timesFound = 0;
for (int i = 0; i <= extra.size() - 4; ) {
unsigned type = static_cast<unsigned>(static_cast<unsigned char>(
extra.at(i)))
| (static_cast<unsigned>(static_cast<unsigned char>(
extra.at(i + 1))) << 8);
i += 2;
unsigned length = static_cast<unsigned>(static_cast<unsigned char>(
extra.at(i)))
| (static_cast<unsigned>(static_cast<unsigned char>(
extra.at(i + 1))) << 8);
i += 2;
if (type == 0x000Au && length >= 32) {
ntfsFound = true;
i += 4; // reserved
while (i <= extra.size() - 4) {
unsigned tag = static_cast<unsigned>(
static_cast<unsigned char>(extra.at(i)))
| (static_cast<unsigned>(
static_cast<unsigned char>(extra.at(i + 1)))
<< 8);
i += 2;
unsigned tagsize = static_cast<unsigned>(
static_cast<unsigned char>(extra.at(i)))
| (static_cast<unsigned>(
static_cast<unsigned char>(extra.at(i + 1)))
<< 8);
i += 2;
QCOMPARE(tagsize, static_cast<unsigned>(24));
if (tag == 0x0001u && tagsize >= 24) {
for (int timesPos = i;
i < timesPos + 24;
i += 8, tagsize -= 8) {
quint64 time = static_cast<quint64>(
static_cast<unsigned char>(extra.at(i)))
| (static_cast<quint64>(static_cast<unsigned char>(
extra.at(i + 1))) << 8)
| (static_cast<quint64>(static_cast<unsigned char>(
extra.at(i + 2))) << 16)
| (static_cast<quint64>(static_cast<unsigned char>(
extra.at(i + 3))) << 24)
| (static_cast<quint64>(static_cast<unsigned char>(
extra.at(i + 4))) << 32)
| (static_cast<quint64>(static_cast<unsigned char>(
extra.at(i + 5))) << 40)
| (static_cast<quint64>(static_cast<unsigned char>(
extra.at(i + 6))) << 48)
| (static_cast<quint64>(static_cast<unsigned char>(
extra.at(i + 7))) << 56);
++timesFound;
if (i - timesPos == 0) {
QCOMPARE(time, mTicks);
} else if (i - timesPos == 8) {
QCOMPARE(time, aTicks);
} else if (i - timesPos == 16) {
QCOMPARE(time, cTicks);
} else {
QFAIL("Wrong position");
}
}
i += tagsize;
} else {
i += tagsize;
}
}
} else {
i += length;
}
}
QVERIFY(ntfsFound);
QCOMPARE(timesFound, 3);
}
removeTestFiles(testFiles);
curDir.remove(zipName);
}
