yshui/lix
0
0
Fork 0
forked from lix-project/lix
Code Pull requests Activity

tests/compression: rewrite

Browse source 
This test suite was in desperate need of using the parameterization
available with gtest, and was a bunch of useless duplicated code. At
least now it's not duplicated code, though it still probably should be
more full of property tests.

Change-Id: Ia8ccee7ef4f02b2fa40417b79aa8c8f0626ea479
This commit is contained in:
jade 2024-09-17 18:34:01 -07:00
parent 8ab5743904
commit 4046e019ca
1 changed files with 132 additions and 100 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

166
tests/unit/libutil/compression.cc
View file

@ -3,105 +3,137 @@
namespace nix { namespace nix {
/* ---------------------------------------------------------------------------- /* ----------------------------------------------------------------------------
* compress / decompress * compress / decompress
* --------------------------------------------------------------------------*/ * --------------------------------------------------------------------------*/
TEST(compress, compressWithUnknownMethod) { TEST(compress, compressWithUnknownMethod)
{
ASSERT_THROW(compress("invalid-method", "something-to-compress"), UnknownCompressionMethod); ASSERT_THROW(compress("invalid-method", "something-to-compress"), UnknownCompressionMethod);
} }
TEST(compress, noneMethodDoesNothingToTheInput) { TEST(compress, noneMethodDoesNothingToTheInput)
{
auto o = compress("none", "this-is-a-test"); auto o = compress("none", "this-is-a-test");
ASSERT_EQ(o, "this-is-a-test"); ASSERT_EQ(o, "this-is-a-test");
} }
TEST(decompress, decompressNoneCompressed) { TEST(decompress, decompressEmptyString)
auto method = "none"; {
auto str = "slfja;sljfklsa;jfklsjfkl;sdjfkl;sadjfkl;sdjf;lsdfjsadlf";
auto o = decompress(method, str);
ASSERT_EQ(o, str);
}
TEST(decompress, decompressEmptyCompressed) {
// Empty-method decompression used e.g. by S3 store // Empty-method decompression used e.g. by S3 store
// (Content-Encoding == ""). // (Content-Encoding == "").
auto method = ""; auto o = decompress("", "this-is-a-test");
auto str = "slfja;sljfklsa;jfklsjfkl;sdjfkl;sadjfkl;sdjf;lsdfjsadlf";
auto o = decompress(method, str);
ASSERT_EQ(o, str); ASSERT_EQ(o, "this-is-a-test");
} }
TEST(decompress, decompressXzCompressed) { /* ----------------------------------------------------------------------------
auto method = "xz"; * compression sinks
* --------------------------------------------------------------------------*/
TEST(makeCompressionSink, noneSinkDoesNothingToInput)
{
auto method = "none";
StringSink strSink;
auto inputString = "slfja;sljfklsa;jfklsjfkl;sdjfkl;sadjfkl;sdjf;lsdfjsadlf";
auto sink = makeCompressionSink(method, strSink);
(*sink)(inputString);
sink->finish();
ASSERT_STREQ(strSink.s.c_str(), inputString);
}
/** Tests applied to all compression types */
class PerTypeCompressionTest : public testing::TestWithParam<const char *>
{};
/** Tests applied to non-passthrough compression types */
class PerTypeNonNullCompressionTest : public testing::TestWithParam<const char *>
{};
constexpr const char * COMPRESSION_TYPES_NONNULL[] = {
// libarchive
"bzip2",
"compress",
"gzip",
"lzip",
"lzma",
"xz",
"zstd",
// Uses external program via libarchive so cannot be used :(
/*
"grzip",
"lrzip",
"lzop",
"lz4",
*/
// custom
"br",
};
INSTANTIATE_TEST_SUITE_P(
compressionNonNull, PerTypeNonNullCompressionTest, testing::ValuesIn(COMPRESSION_TYPES_NONNULL)
);
INSTANTIATE_TEST_SUITE_P(
compressionNonNull, PerTypeCompressionTest, testing::ValuesIn(COMPRESSION_TYPES_NONNULL)
);
INSTANTIATE_TEST_SUITE_P(
compressionNull, PerTypeCompressionTest, testing::Values("none")
);
/* ---------------------------------------
* All compression types
* --------------------------------------- */
TEST_P(PerTypeCompressionTest, roundTrips)
{
auto method = GetParam();
auto str = "slfja;sljfklsa;jfklsjfkl;sdjfkl;sadjfkl;sdjf;lsdfjsadlf"; auto str = "slfja;sljfklsa;jfklsjfkl;sdjfkl;sadjfkl;sdjf;lsdfjsadlf";
auto o = decompress(method, compress(method, str)); auto o = decompress(method, compress(method, str));
ASSERT_EQ(o, str); ASSERT_EQ(o, str);
} }
TEST(decompress, decompressBzip2Compressed) { TEST_P(PerTypeCompressionTest, longerThanBuffer)
auto method = "bzip2"; {
auto str = "slfja;sljfklsa;jfklsjfkl;sdjfkl;sadjfkl;sdjf;lsdfjsadlf"; // This is targeted originally at regression testing a brotli bug, but we might as well do it to
auto o = decompress(method, compress(method, str)); // everything
auto method = GetParam();
ASSERT_EQ(o, str);
}
TEST(decompress, decompressBrCompressed) {
auto method = "br";
auto str = "slfja;sljfklsa;jfklsjfkl;sdjfkl;sadjfkl;sdjf;lsdfjsadlf";
auto o = decompress(method, compress(method, str));
ASSERT_EQ(o, str);
}
TEST(decompress, decompressInvalidInputThrowsCompressionError) {
auto method = "bzip2";
auto str = "this is a string that does not qualify as valid bzip2 data";
ASSERT_THROW(decompress(method, str), CompressionError);
}
TEST(decompress, veryLongBrotli) {
auto method = "br";
auto str = std::string(65536, 'a'); auto str = std::string(65536, 'a');
auto o = decompress(method, compress(method, str)); auto o = decompress(method, compress(method, str));
// This is just to not print 64k of "a" for most failures // This is just to not print 64k of "a" for most failures
ASSERT_EQ(o.length(), str.length()); ASSERT_EQ(o.length(), str.length());
ASSERT_EQ(o, str); ASSERT_EQ(o, str);
} }
/* ---------------------------------------------------------------------------- TEST_P(PerTypeCompressionTest, sinkAndSource)
* compression sinks {
* --------------------------------------------------------------------------*/ auto method = GetParam();
TEST(makeCompressionSink, noneSinkDoesNothingToInput) {
StringSink strSink;
auto inputString = "slfja;sljfklsa;jfklsjfkl;sdjfkl;sadjfkl;sdjf;lsdfjsadlf";
auto sink = makeCompressionSink("none", strSink);
(*sink)(inputString);
sink->finish();
ASSERT_STREQ(strSink.s.c_str(), inputString);
}
TEST(makeCompressionSink, compressAndDecompress) {
auto inputString = "slfja;sljfklsa;jfklsjfkl;sdjfkl;sadjfkl;sdjf;lsdfjsadlf"; auto inputString = "slfja;sljfklsa;jfklsjfkl;sdjfkl;sadjfkl;sdjf;lsdfjsadlf";
StringSink strSink; StringSink strSink;
auto sink = makeCompressionSink("bzip2", strSink); auto sink = makeCompressionSink(method, strSink);
(*sink)(inputString); (*sink)(inputString);
sink->finish(); sink->finish();
StringSource strSource{strSink.s}; StringSource strSource{strSink.s};
auto decompressionSource = makeDecompressionSource("bzip2", strSource); auto decompressionSource = makeDecompressionSource(method, strSource);
ASSERT_STREQ(decompressionSource->drain().c_str(), inputString); ASSERT_STREQ(decompressionSource->drain().c_str(), inputString);
} }
/* ---------------------------------------
* Non null compression types
* --------------------------------------- */
TEST_P(PerTypeNonNullCompressionTest, bogusInputDecompression)
{
auto param = GetParam();
auto bogus = "this data is bogus and should throw when decompressing";
ASSERT_THROW(decompress(param, bogus), CompressionError);
}
} }