tests/create_compress_files.c

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 /// \file       create_compress_files.c
   4 /// \brief      Creates bunch of test files to be compressed
   5 ///
   6 /// Using a test file generator program saves space in the source code
   7 /// package considerably.
   8 //
   9 //  Author:     Lasse Collin
  10 //
  11 //  This file has been put into the public domain.
  12 //  You can do whatever you want with this file.
  13 //
  14 ///////////////////////////////////////////////////////////////////////////////
  15
  16 #include "sysdefs.h"
  17 #include <stdio.h>
  18
  19
  20 // Avoid re-creating the test files every time the tests are run.
  21 #define create_test(name) \
  22 do { \
  23         if (!file_exists("compress_generated_" #name)) { \
  24                 FILE *file = file_create("compress_generated_" #name); \
  25                 write_ ## name(file); \
  26                 file_finish(file, "compress_generated_" #name); \
  27         } \
  28 } while (0)
  29
  30
  31 static bool
  32 file_exists(const char *filename)
  33 {
  34         // Trying to be somewhat portable by avoiding stat().
  35         FILE *file = fopen(filename, "rb");
  36         bool ret;
  37
  38         if (file != NULL) {
  39                 fclose(file);
  40                 ret = true;
  41         } else {
  42                 ret = false;
  43         }
  44
  45         return ret;
  46 }
  47
  48
  49 static FILE *
  50 file_create(const char *filename)
  51 {
  52         FILE *file = fopen(filename, "wb");
  53
  54         if (file == NULL) {
  55                 perror(filename);
  56                 exit(1);
  57         }
  58
  59         return file;
  60 }
  61
  62
  63 static void
  64 file_finish(FILE *file, const char *filename)
  65 {
  66         const bool ferror_fail = ferror(file);
  67         const bool fclose_fail = fclose(file);
  68
  69         if (ferror_fail || fclose_fail) {
  70                 perror(filename);
  71                 exit(1);
  72         }
  73 }
  74
  75
  76 // File that repeats "abc\n" a few thousand times. This is targeted
  77 // especially at Subblock filter's run-length encoder.
  78 static void
  79 write_abc(FILE *file)
  80 {
  81         for (size_t i = 0; i < 12345; ++i)
  82                 if (fwrite("abc\n", 4, 1, file) != 1)
  83                         exit(1);
  84 }
  85
  86
  87 // File that doesn't compress. We always use the same random seed to
  88 // generate identical files on all systems.
  89 static void
  90 write_random(FILE *file)
  91 {
  92         uint32_t n = 5;
  93
  94         for (size_t i = 0; i < 123456; ++i) {
  95                 n = 101771 * n + 71777;
  96
  97                 putc(n & 0xFF, file);
  98                 putc((n >> 8) & 0xFF, file);
  99                 putc((n >> 16) & 0xFF, file);
 100                 putc(n >> 24, file);
 101         }
 102 }
 103
 104
 105 // Text file
 106 static void
 107 write_text(FILE *file)
 108 {
 109         static const char *lorem[] = {
 110                 "Lorem", "ipsum", "dolor", "sit", "amet,", "consectetur",
 111                 "adipisicing", "elit,", "sed", "do", "eiusmod", "tempor",
 112                 "incididunt", "ut", "labore", "et", "dolore", "magna",
 113                 "aliqua.", "Ut", "enim", "ad", "minim", "veniam,", "quis",
 114                 "nostrud", "exercitation", "ullamco", "laboris", "nisi",
 115                 "ut", "aliquip", "ex", "ea", "commodo", "consequat.",
 116                 "Duis", "aute", "irure", "dolor", "in", "reprehenderit",
 117                 "in", "voluptate", "velit", "esse", "cillum", "dolore",
 118                 "eu", "fugiat", "nulla", "pariatur.", "Excepteur", "sint",
 119                 "occaecat", "cupidatat", "non", "proident,", "sunt", "in",
 120                 "culpa", "qui", "officia", "deserunt", "mollit", "anim",
 121                 "id", "est", "laborum."
 122         };
 123
 124         // Let the first paragraph be the original text.
 125         for (size_t w = 0; w < ARRAY_SIZE(lorem); ++w) {
 126                 fprintf(file, "%s ", lorem[w]);
 127
 128                 if (w % 7 == 6)
 129                         fprintf(file, "\n");
 130         }
 131
 132         // The rest shall be (hopefully) meaningless combinations of
 133         // the same words.
 134         uint32_t n = 29;
 135
 136         for (size_t p = 0; p < 500; ++p) {
 137                 fprintf(file, "\n\n");
 138
 139                 for (size_t w = 0; w < ARRAY_SIZE(lorem); ++w) {
 140                         n = 101771 * n + 71777;
 141
 142                         fprintf(file, "%s ", lorem[n % ARRAY_SIZE(lorem)]);
 143
 144                         if (w % 7 == 6)
 145                                 fprintf(file, "\n");
 146                 }
 147         }
 148 }
 149
 150
 151 int
 152 main(void)
 153 {
 154         create_test(abc);
 155         create_test(random);
 156         create_test(text);
 157         return 0;
 158 }