File indexing completed on 2024-04-21 03:52:29

 /*
  *  SPDX-FileCopyrightText: 2002-2005 David Faure <faure@kde.org>
  *
  *  SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 #include "kfiltertest.h"
 
 #include <QBuffer>
 #include <QRandomGenerator>
 #include <QSaveFile>
 #include <QTest>
 
 #include "kcompressiondevice.h"
 #include "kfilterbase.h"
 #include <QDebug>
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QTextStream>
 #include <config-compression.h>
 #include <zlib.h>
 
 #ifdef Q_OS_UNIX
 #include <limits.h>
 #include <unistd.h>
 #endif
 
 QTEST_MAIN(KFilterTest)
 
 void KFilterTest::initTestCase()
 {
     qRegisterMetaType<KCompressionDevice::CompressionType>();
     const QString currentdir = QDir::currentPath();
     pathgz = currentdir + "/test.gz";
     pathbz2 = currentdir + "/test.bz2";
     pathxz = currentdir + "/test.xz";
     pathnone = currentdir + "/test.txt";
     pathzstd = currentdir + "/test.zst";
 
     // warning, update the COMPAREs in test_block_write() if changing the test data...
     testData = "hello world\n";
 }
 
 void KFilterTest::test_block_write(const QString &fileName, const QByteArray &data, int nTimes)
 {
     KCompressionDevice dev(fileName);
     bool ok = dev.open(QIODevice::WriteOnly);
     QVERIFY(ok);
 
     for (int i = 0; i < nTimes; ++i) {
         const int ret = dev.write(data);
         QCOMPARE(ret, data.size());
     }
 
     dev.close();
 
     QVERIFY(QFile::exists(fileName));
 }
 
 void KFilterTest::test_block_write()
 {
     // First we do it 50 times, to make sure the compressor
     // can "reuse" existing data, i.e. zstd used to have a bug
     // that made this use 513 bytes instead of 28
     qDebug() << " -- test_block_write gzip -- ";
     test_block_write(pathgz, testData, 50);
     QCOMPARE(QFileInfo(pathgz).size(), 40LL); // size of test.gz
 
 #if HAVE_BZIP2_SUPPORT
     qDebug() << " -- test_block_write bzip2 -- ";
     test_block_write(pathbz2, testData, 50);
     QCOMPARE(QFileInfo(pathbz2).size(), 64LL); // size of test.bz2
 #endif
 
 #if HAVE_XZ_SUPPORT
     qDebug() << " -- test_block_write xz -- ";
     test_block_write(pathxz, testData, 50);
     QCOMPARE(QFileInfo(pathxz).size(), 84LL); // size of test.lzma
 #endif
 
     qDebug() << " -- test_block_write none -- ";
     test_block_write(pathnone, testData, 50);
     QCOMPARE(QFileInfo(pathnone).size(), 600LL); // size of test.txt
 
 #if HAVE_ZSTD_SUPPORT
     qDebug() << " -- test_block_write zstd -- ";
     test_block_write(pathzstd, testData, 50);
     QCOMPARE(QFileInfo(pathzstd).size(), 28LL); // size of test.zst
 #endif
 
     // Then do the write data just once because test_block_read
     // depends on this
     qDebug() << " -- test_block_write gzip -- ";
     test_block_write(pathgz, testData);
     QCOMPARE(QFileInfo(pathgz).size(), 33LL); // size of test.gz
 
 #if HAVE_BZIP2_SUPPORT
     qDebug() << " -- test_block_write bzip2 -- ";
     test_block_write(pathbz2, testData);
     QCOMPARE(QFileInfo(pathbz2).size(), 52LL); // size of test.bz2
 #endif
 
 #if HAVE_XZ_SUPPORT
     qDebug() << " -- test_block_write xz -- ";
     test_block_write(pathxz, testData);
     QCOMPARE(QFileInfo(pathxz).size(), 64LL); // size of test.lzma
 #endif
 
     qDebug() << " -- test_block_write none -- ";
     test_block_write(pathnone, testData);
     QCOMPARE(QFileInfo(pathnone).size(), 12LL); // size of test.txt
 
 #if HAVE_ZSTD_SUPPORT
     qDebug() << " -- test_block_write zstd -- ";
     test_block_write(pathzstd, testData);
     QCOMPARE(QFileInfo(pathzstd).size(), 21LL); // size of test.zst
 #endif
 }
 
 void KFilterTest::test_biggerWrites()
 {
     const QString currentdir = QDir::currentPath();
     const QString outFile = currentdir + "/test_big.gz";
     // Find the out-of-bounds from #157706/#188415
     QByteArray data;
     data.reserve(10000);
     auto *generator = QRandomGenerator::global();
     // Prepare test data
     for (int i = 0; i < 8170; ++i) {
         data.append((char)(generator->bounded(256)));
     }
     QCOMPARE(data.size(), 8170);
     // 8170 random bytes compress to 8194 bytes due to the gzip header/footer.
     // Now we can go one by one until we pass 8192.
     // On 32 bit systems it crashed with data.size()=8173, before the "no room for footer yet" fix.
     int compressedSize = 0;
     while (compressedSize < 8200) {
         test_block_write(outFile, data);
         compressedSize = QFileInfo(outFile).size();
         qDebug() << data.size() << "compressed into" << compressedSize;
         // Test data is valid
         test_readall(outFile, QString::fromLatin1("application/gzip"), data);
 
         data.append((char)(generator->bounded(256)));
     }
 }
 
 void KFilterTest::test_block_read(const QString &fileName)
 {
     KCompressionDevice dev(fileName);
     bool ok = dev.open(QIODevice::ReadOnly);
     QVERIFY(ok);
 
     QByteArray array(1024, '\0');
     QByteArray read;
     int n;
     while ((n = dev.read(array.data(), array.size()))) {
         QVERIFY(n > 0);
         read += QByteArray(array.constData(), n);
         // qDebug() << "read returned " << n;
         // qDebug() << "read='" << read << "'";
 
         // pos() has no real meaning on sequential devices
         // Ah, but kzip uses kfilterdev as a non-sequential device...
 
         QCOMPARE((int)dev.pos(), (int)read.size());
         // qDebug() << "dev.at = " << dev->at();
     }
     QCOMPARE(read, testData);
 
     // Test seeking back
     ok = dev.seek(0);
     // test readAll
     read = dev.readAll();
     QCOMPARE(read.size(), testData.size());
     QCOMPARE(read, testData);
 
     dev.close();
 }
 
 void KFilterTest::test_block_read()
 {
     qDebug() << " -- test_block_read gzip -- ";
     test_block_read(pathgz);
 #if HAVE_BZIP2_SUPPORT
     qDebug() << " -- test_block_read bzip2 -- ";
     test_block_read(pathbz2);
 #endif
 #if HAVE_XZ_SUPPORT
     qDebug() << " -- test_block_read lzma -- ";
     test_block_read(pathxz);
 #endif
     qDebug() << " -- test_block_read none -- ";
     test_block_read(pathnone);
 #if HAVE_ZSTD_SUPPORT
     qDebug() << " -- test_block_read zstd -- ";
     test_block_read(pathzstd);
 #endif
 }
 
 void KFilterTest::test_getch(const QString &fileName)
 {
     KCompressionDevice dev(fileName);
     bool ok = dev.open(QIODevice::ReadOnly);
     QVERIFY(ok);
     QByteArray read;
     char ch;
     while (dev.getChar(&ch)) {
         // printf("%c",ch);
         read += ch;
     }
     dev.close();
     QCOMPARE(read, testData);
 }
 
 void KFilterTest::test_getch()
 {
     qDebug() << " -- test_getch gzip -- ";
     test_getch(pathgz);
 #if HAVE_BZIP2_SUPPORT
     qDebug() << " -- test_getch bzip2 -- ";
     test_getch(pathbz2);
 #endif
 #if HAVE_XZ_SUPPORT
     qDebug() << " -- test_getch lzma -- ";
     test_getch(pathxz);
 #endif
     qDebug() << " -- test_getch none -- ";
     test_getch(pathnone);
 #if HAVE_ZSTD_SUPPORT
     qDebug() << " -- test_getch zstd -- ";
     test_getch(pathzstd);
 #endif
 }
 
 void KFilterTest::test_textstream(const QString &fileName)
 {
     KCompressionDevice dev(fileName);
     bool ok = dev.open(QIODevice::ReadOnly);
     QVERIFY(ok);
     QTextStream ts(&dev);
     QString readStr = ts.readAll();
     dev.close();
 
     QByteArray read = readStr.toLatin1();
     QCOMPARE(read, testData);
 }
 
 void KFilterTest::test_textstream()
 {
     qDebug() << " -- test_textstream gzip -- ";
     test_textstream(pathgz);
 #if HAVE_BZIP2_SUPPORT
     qDebug() << " -- test_textstream bzip2 -- ";
     test_textstream(pathbz2);
 #endif
 #if HAVE_XZ_SUPPORT
     qDebug() << " -- test_textstream lzma -- ";
     test_textstream(pathxz);
 #endif
     qDebug() << " -- test_textstream none -- ";
     test_textstream(pathnone);
 #if HAVE_ZSTD_SUPPORT
     qDebug() << " -- test_textstream zstd -- ";
     test_textstream(pathzstd);
 #endif
 }
 
 void KFilterTest::test_readall(const QString &fileName, const QString &mimeType, const QByteArray &expectedData)
 {
     QFile file(fileName);
     KCompressionDevice::CompressionType type = KCompressionDevice::compressionTypeForMimeType(mimeType);
     KCompressionDevice flt(&file, false, type);
     bool ok = flt.open(QIODevice::ReadOnly);
     QVERIFY(ok);
     const QByteArray read = flt.readAll();
     QCOMPARE(read.size(), expectedData.size());
     QCOMPARE(read, expectedData);
 
     // Now using QBuffer
     file.seek(0);
     QByteArray compressedData = file.readAll();
     QVERIFY(!compressedData.isEmpty());
     QBuffer buffer(&compressedData);
     KCompressionDevice device(&buffer, false, type);
     QVERIFY(device.open(QIODevice::ReadOnly));
     QCOMPARE(device.readAll(), expectedData);
 }
 
 void KFilterTest::test_readall()
 {
     qDebug() << " -- test_readall gzip -- ";
     test_readall(pathgz, QString::fromLatin1("application/gzip"), testData);
 #if HAVE_BZIP2_SUPPORT
     qDebug() << " -- test_readall bzip2 -- ";
     test_readall(pathbz2, QString::fromLatin1("application/x-bzip"), testData);
 #endif
 #if HAVE_XZ_SUPPORT
     qDebug() << " -- test_readall lzma -- ";
     test_readall(pathxz, QString::fromLatin1("application/x-xz"), testData);
 #endif
     qDebug() << " -- test_readall gzip-derived -- ";
     test_readall(pathgz, QString::fromLatin1("image/svg+xml-compressed"), testData);
 
     qDebug() << " -- test_readall none -- ";
     test_readall(pathnone, QString::fromLatin1("text/plain"), testData);
 
 #if HAVE_ZSTD_SUPPORT
     qDebug() << " -- test_readall zstd -- ";
     test_readall(pathzstd, QString::fromLatin1("application/zstd"), testData);
 #endif
 }
 
 void KFilterTest::test_uncompressed()
 {
     // Can KCompressionDevice handle uncompressed data even when using gzip decompression?
     qDebug() << " -- test_uncompressed -- ";
     QBuffer buffer(&testData);
     buffer.open(QIODevice::ReadOnly);
     KCompressionDevice::CompressionType type = KCompressionDevice::compressionTypeForMimeType(QString::fromLatin1("application/gzip"));
     KCompressionDevice flt(&buffer, false, type);
     bool ok = flt.open(QIODevice::ReadOnly);
     QVERIFY(ok);
     QByteArray read = flt.readAll();
     QCOMPARE(read.size(), testData.size());
     QCOMPARE(read, testData);
 }
 
 void KFilterTest::test_findFilterByMimeType_data()
 {
     QTest::addColumn<QString>("mimeType");
     QTest::addColumn<KCompressionDevice::CompressionType>("type");
 
     // direct mimetype name
     QTest::newRow("application/gzip") << QString::fromLatin1("application/gzip") << KCompressionDevice::GZip;
 #if HAVE_BZIP2_SUPPORT
     QTest::newRow("application/x-bzip") << QString::fromLatin1("application/x-bzip") << KCompressionDevice::BZip2;
     QTest::newRow("application/x-bzip2") << QString::fromLatin1("application/x-bzip2") << KCompressionDevice::BZip2;
 #else
     QTest::newRow("application/x-bzip") << QString::fromLatin1("application/x-bzip") << KCompressionDevice::None;
     QTest::newRow("application/x-bzip2") << QString::fromLatin1("application/x-bzip2") << KCompressionDevice::None;
 #endif
     // indirect compressed mimetypes
     QTest::newRow("application/x-gzdvi") << QString::fromLatin1("application/x-gzdvi") << KCompressionDevice::GZip;
 
     // non-compressed mimetypes
     QTest::newRow("text/plain") << QString::fromLatin1("text/plain") << KCompressionDevice::None;
     QTest::newRow("application/x-tar") << QString::fromLatin1("application/x-tar") << KCompressionDevice::None;
 }
 
 void KFilterTest::test_findFilterByMimeType()
 {
     QFETCH(QString, mimeType);
     QFETCH(KCompressionDevice::CompressionType, type);
 
     KCompressionDevice::CompressionType compressionType = KCompressionDevice::compressionTypeForMimeType(mimeType);
     QCOMPARE(compressionType, type);
 }
 
 static void getCompressedData(QByteArray &data, QByteArray &compressedData)
 {
     data = "Hello world, this is a test for deflate, from bug 114830 / 117683";
     compressedData.resize(long(data.size() * 1.1f) + 12L); // requirements of zlib::compress2
     unsigned long out_bufferlen = compressedData.size();
     const int ret = compress2((Bytef *)compressedData.data(), &out_bufferlen, (const Bytef *)data.constData(), data.size(), 1);
     QCOMPARE(ret, Z_OK);
     compressedData.resize(out_bufferlen);
 }
 
 void KFilterTest::test_deflateWithZlibHeader()
 {
     QByteArray data;
     QByteArray deflatedData;
     getCompressedData(data, deflatedData);
 
 #if 0 // Can't use KFilterDev for this, we need to call KGzipFilter::init(QIODevice::ReadOnly, KGzipFilter::ZlibHeader);
     QBuffer buffer(&deflatedData);
     QIODevice *flt = KFilterDev::device(&buffer, "application/gzip", false);
     static_cast<KFilterDev *>(flt)->setSkipHeaders();
     bool ok = flt->open(QIODevice::ReadOnly);
     QVERIFY(ok);
     const QByteArray read = flt->readAll();
 #else
     // Copied from HTTPFilter (which isn't linked into any kdelibs library)
     KFilterBase *mFilterDevice = KCompressionDevice::filterForCompressionType(KCompressionDevice::GZip);
     mFilterDevice->setFilterFlags(KFilterBase::ZlibHeaders);
     mFilterDevice->init(QIODevice::ReadOnly);
 
     mFilterDevice->setInBuffer(deflatedData.constData(), deflatedData.size());
     char buf[8192];
     mFilterDevice->setOutBuffer(buf, sizeof(buf));
     KFilterBase::Result result = mFilterDevice->uncompress();
     QCOMPARE(result, KFilterBase::End);
     const int bytesOut = sizeof(buf) - mFilterDevice->outBufferAvailable();
     QVERIFY(bytesOut);
     QByteArray read(buf, bytesOut);
     mFilterDevice->terminate();
     delete mFilterDevice;
 #endif
     QCOMPARE(QString::fromLatin1(read.constData()), QString::fromLatin1(data.constData())); // more readable output than the line below
     QCOMPARE(read, data);
 
     // For the same test with HTTPFilter: see httpfiltertest.cpp
 }
 
 void KFilterTest::test_pushData() // ### UNFINISHED
 {
     // HTTPFilter says KFilterDev doesn't support the case where compressed data
     // is arriving in chunks. Let's test that.
     QFile file(pathgz);
     QVERIFY(file.open(QIODevice::ReadOnly));
     const QByteArray compressed = file.readAll();
     const int firstChunkSize = compressed.size() / 2;
     QByteArray firstData(compressed.constData(), firstChunkSize);
     QBuffer inBuffer(&firstData);
     QVERIFY(inBuffer.open(QIODevice::ReadWrite));
     KCompressionDevice::CompressionType type = KCompressionDevice::compressionTypeForMimeType(QString::fromLatin1("application/gzip"));
     KCompressionDevice flt(&inBuffer, false, type);
     QVERIFY(flt.open(QIODevice::ReadOnly));
     QByteArray read = flt.readAll();
     qDebug() << QString::fromLatin1(read.constData());
 
     // And later...
     inBuffer.write(QByteArray(compressed.data() + firstChunkSize, compressed.size() - firstChunkSize));
     QCOMPARE(inBuffer.data().size(), compressed.size());
     read += flt.readAll();
     qDebug() << QString::fromLatin1(read.constData());
     // ### indeed, doesn't work currently. So we use HTTPFilter instead, for now.
 }
 
 void KFilterTest::test_saveFile_data()
 {
     QTest::addColumn<QString>("fileName");
     QTest::addColumn<KCompressionDevice::CompressionType>("compressionType");
 
     QTest::newRow("gz") << "test_saveFile.gz" << KCompressionDevice::GZip;
     QTest::newRow("none") << "test_saveFile" << KCompressionDevice::None;
 }
 
 void KFilterTest::test_saveFile()
 {
     QFETCH(QString, fileName);
     QFETCH(KCompressionDevice::CompressionType, compressionType);
 
     int numLines = 1000;
     const QString lineTemplate = QStringLiteral("Hello world, this is the text for line %1");
     const QString currentdir = QDir::currentPath();
     const QString outFile = QDir::currentPath() + '/' + fileName;
     {
         QSaveFile file(outFile);
         file.setDirectWriteFallback(true);
         QVERIFY(file.open(QIODevice::WriteOnly));
         KCompressionDevice device(&file, false, compressionType);
         QVERIFY(device.open(QIODevice::WriteOnly));
         QTextStream stream(&device);
         for (int i = 0; i < numLines; ++i) {
             stream << lineTemplate.arg(i);
             stream << QString("\n");
         }
         stream.flush();
         QCOMPARE(stream.status(), QTextStream::Ok);
         // device.write("The data to be compressed");
         device.close();
         QVERIFY(file.commit());
     }
     QVERIFY(QFile::exists(outFile));
     KCompressionDevice reader(outFile, compressionType);
     QVERIFY(reader.open(QIODevice::ReadOnly));
     QString expectedFullData;
     for (int i = 0; i < numLines; ++i) {
         QCOMPARE(QString::fromUtf8(reader.readLine()), QString(lineTemplate.arg(i) + '\n'));
         expectedFullData += QString(lineTemplate.arg(i) + '\n');
     }
     KCompressionDevice otherReader(outFile);
     QVERIFY(otherReader.open(QIODevice::ReadOnly));
     QCOMPARE(QString::fromLatin1(otherReader.readAll()), expectedFullData);
     QVERIFY(otherReader.atEnd());
 }
 
 void KFilterTest::test_twofilesgztogether()
 {
     // Reported as 232843
     // twofiles generated with
     // echo foo > foo; echo bar > bar ; gzip -c foo > twofiles.gz; gzip -c bar >> twofiles.gz
     // as documented in the gzip manpage
     QString data = QFINDTESTDATA("data/twofiles.gz");
     KCompressionDevice dev(data);
     QVERIFY(dev.open(QIODevice::ReadOnly));
     QByteArray extractedData = dev.readAll();
     QByteArray expectedData{"foo\nbar\n"};
     QCOMPARE(extractedData, expectedData);
 }
 
 void KFilterTest::test_threefilesgztogether()
 {
     // Generated similarly to the one above
     // This catches the case where there's more than two streams available in the same buffer fed to KGzipFilter
     QString data = QFINDTESTDATA("data/threefiles.gz");
     KCompressionDevice dev(data);
     QVERIFY(dev.open(QIODevice::ReadOnly));
     QByteArray extractedData = dev.readAll();
     QByteArray expectedData{"foo\nbar\nbaz\n"};
     QCOMPARE(extractedData, expectedData);
 }
 
 #include "moc_kfiltertest.cpp"