test-compress: also test with incompressible inputs

diff --git a/src/journal/test-compress.c b/src/journal/test-compress.c
index 026d630ac2a851d5cae400eaf89c9b3a4c99446a..78b3203befe52964f22ebb3d5bef77f0e4d61ec6 100644 (file)
--- a/src/journal/test-compress.c
+++ b/src/journal/test-compress.c
@@ -48,25 +48,31 @@ typedef int (decompress_stream_t)(int fdf, int fdt, off_t max_size);
 
 static void test_compress_decompress(int compression,
                                      compress_blob_t compress,
-                                     decompress_blob_t decompress) {
-        char text[] = "foofoofoofoo AAAA aaaaaaaaa ghost busters barbarbar FFF"
-                      "foofoofoofoo AAAA aaaaaaaaa ghost busters barbarbar FFF";
+                                     decompress_blob_t decompress,
+                                     const char *data,
+                                     size_t data_len,
+                                     bool may_fail) {
         char compressed[512];
         size_t csize = 512;
         size_t usize = 0;
         _cleanup_free_ char *decompressed = NULL;
         int r;
 
-        log_info("/* testing %s blob compression/decompression */",
-                 object_compressed_to_string(compression));
-
-        r = compress(text, sizeof(text), compressed, &csize);
-        assert(r == 0);
-        r = decompress(compressed, csize,
-                       (void **) &decompressed, &usize, &csize, 0);
-        assert(r == 0);
-        assert_se(decompressed);
-        assert_se(streq(decompressed, text));
+        log_info("/* testing %s %s blob compression/decompression */",
+                 object_compressed_to_string(compression), data);
+
+        r = compress(data, data_len, compressed, &csize);
+        if (r == -ENOBUFS) {
+                log_info("compression failed: %s", strerror(-r));
+                assert(may_fail);
+        } else {
+                assert(r == 0);
+                r = decompress(compressed, csize,
+                               (void **) &decompressed, &usize, &csize, 0);
+                assert(r == 0);
+                assert_se(decompressed);
+                assert_se(memcmp(decompressed, data, data_len) == 0);
+        }
 
         r = decompress("garbage", 7,
                        (void **) &decompressed, &usize, &csize, 0);
@@ -86,29 +92,38 @@ static void test_compress_decompress(int compression,
 
 static void test_decompress_startswith(int compression,
                                        compress_blob_t compress,
-                                       decompress_sw_t decompress_sw) {
+                                       decompress_sw_t decompress_sw,
+                                       const char *data,
+                                       size_t data_len,
+                                       bool may_fail) {
 
-        char text[] = "foofoofoofoo AAAA aaaaaaaaa ghost busters barbarbar FFF"
-                      "foofoofoofoo AAAA aaaaaaaaa ghost busters barbarbar FFF";
         char compressed[512];
         size_t csize = 512;
         size_t usize = 0;
         _cleanup_free_ char *decompressed = NULL;
+        int r;
 
-        log_info("/* testing decompress_startswith with %s */",
-                 object_compressed_to_string(compression));
+        log_info("/* testing decompress_startswith with %s on %s text*/",
+                 object_compressed_to_string(compression), data);
+
+        r = compress(data, data_len, compressed, &csize);
+        if (r == -ENOBUFS) {
+                log_info("compression failed: %s", strerror(-r));
+                assert(may_fail);
+                return;
+        }
+        assert(r == 0);
 
-        assert_se(compress(text, sizeof(text), compressed, &csize) == 0);
         assert_se(decompress_sw(compressed,
                                 csize,
                                 (void **) &decompressed,
                                 &usize,
-                                "foofoofoofoo", 12, ' ') > 0);
+                                data, strlen(data), '\0') > 0);
         assert_se(decompress_sw(compressed,
                                 csize,
                                 (void **) &decompressed,
                                 &usize,
-                                "foofoofoofoo", 12, 'w') == 0);
+                                data, strlen(data), 'w') == 0);
         assert_se(decompress_sw(compressed,
                                 csize,
                                 (void **) &decompressed,
@@ -118,7 +133,7 @@ static void test_decompress_startswith(int compression,
                                 csize,
                                 (void **) &decompressed,
                                 &usize,
-                                "foofoofoofoo", 12, ' ') > 0);
+                                data, strlen(data), '\0') > 0);
 }
 
 static void test_compress_stream(int compression,
@@ -181,20 +196,44 @@ static void test_compress_stream(int compression,
 }
 
 int main(int argc, char *argv[]) {
+        const char text[] =
+                "text\0foofoofoofoo AAAA aaaaaaaaa ghost busters barbarbar FFF"
+                "foofoofoofoo AAAA aaaaaaaaa ghost busters barbarbar FFF";
+
+        char data[512] = "random\0";
 
         log_set_max_level(LOG_DEBUG);
 
+        random_bytes(data + 7, sizeof(data) - 7);
+
 #ifdef HAVE_XZ
-        test_compress_decompress(OBJECT_COMPRESSED_XZ, compress_blob_xz, decompress_blob_xz);
-        test_decompress_startswith(OBJECT_COMPRESSED_XZ, compress_blob_xz, decompress_startswith_xz);
+        test_compress_decompress(OBJECT_COMPRESSED_XZ, compress_blob_xz, decompress_blob_xz,
+                                 text, sizeof(text), false);
+        test_compress_decompress(OBJECT_COMPRESSED_XZ, compress_blob_xz, decompress_blob_xz,
+                                 data, sizeof(data), true);
+        test_decompress_startswith(OBJECT_COMPRESSED_XZ,
+                                   compress_blob_xz, decompress_startswith_xz,
+                                   text, sizeof(text), false);
+        test_decompress_startswith(OBJECT_COMPRESSED_XZ,
+                                   compress_blob_xz, decompress_startswith_xz,
+                                   data, sizeof(data), true);
         test_compress_stream(OBJECT_COMPRESSED_XZ, "xzcat",
                              compress_stream_xz, decompress_stream_xz, argv[0]);
 #else
         log_info("/* XZ test skipped */");
 #endif
+
 #ifdef HAVE_LZ4
-        test_compress_decompress(OBJECT_COMPRESSED_LZ4, compress_blob_lz4, decompress_blob_lz4);
-        test_decompress_startswith(OBJECT_COMPRESSED_LZ4, compress_blob_lz4, decompress_startswith_lz4);
+        test_compress_decompress(OBJECT_COMPRESSED_LZ4, compress_blob_lz4, decompress_blob_lz4,
+                                 text, sizeof(text), false);
+        test_compress_decompress(OBJECT_COMPRESSED_LZ4, compress_blob_lz4, decompress_blob_lz4,
+                                 data, sizeof(data), true);
+        test_decompress_startswith(OBJECT_COMPRESSED_LZ4,
+                                   compress_blob_lz4, decompress_startswith_lz4,
+                                   text, sizeof(text), false);
+        test_decompress_startswith(OBJECT_COMPRESSED_LZ4,
+                                   compress_blob_lz4, decompress_startswith_lz4,
+                                   data, sizeof(data), true);
 
         /* Produced stream is not compatible with lz4 binary, skip lz4cat check. */
         test_compress_stream(OBJECT_COMPRESSED_LZ4, NULL,