lzwtester.c

////////////////////////////////////////////////////////////////////////////
//                            **** LZW-AB ****                            //
//               Adjusted Binary LZW Compressor/Decompressor              //
//                  Copyright (c) 2016-2020 David Bryant                  //
//                           All Rights Reserved                          //
//      Distributed under the BSD Software License (see license.txt)      //
////////////////////////////////////////////////////////////////////////////

#include <sys/stat.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif

#include "lzwlib.h"

/* This module provides a command-line test harness for the lzw library.
 * Given a list of files, it will read each one and byte-for-byte verify
 * the data after a round-trip through a compression / decompression cycle
 * at each of the 8 available maximum symbol size settings.
 *
 * It can also optionally perform fuzz testing by randomly corrupting the
 * compressed bitstream. Obviously this will introduce integrity failures,
 * but it should not cause a crash. It also has an "exhaustive" mode that
 * creates hundreds of simulated images from each input file by successive
 * truncation from both ends.
 */

static const char *usage =
" Usage:     lzwtester [options] file [...]\n\n"
" Options:   -1 ... -8 = test using only specified max symbol size (9 - 16)\n"
"            -0        = cycle through all maximum symbol sizes (default)\n"
"            -e        = exhaustive test (by successive truncation)\n"
"            -f        = fuzz test (randomly corrupt compressed data)\n"
"            -q        = quiet mode (only reports errors and summary)\n\n"
" Web:       Visit www.github.com/dbry/lzw-ab for latest version and info\n\n";

typedef struct {
    unsigned int size, index, wrapped, byte_errors, first_error, fuzz_testing;
    unsigned char *buffer;
} streamer;

static int read_buff (void *ctx)
{
    streamer *stream = ctx;

    if (stream->index == stream->size)
        return EOF;

    return stream->buffer [stream->index++];
}

static void write_buff (int value, void *ctx)
{
    streamer *stream = ctx;

    // for fuzz testing, randomly corrupt 1 byte in every 65536 (on average)

    if (stream->fuzz_testing) {
        static unsigned long long kernel = 0x3141592653589793;
        kernel = ((kernel << 4) - kernel) ^ 1;
        kernel = ((kernel << 4) - kernel) ^ 1;
        kernel = ((kernel << 4) - kernel) ^ 1;

        if (!(kernel >> 48))
            value ^= (int)(kernel >> 40);
    }

    if (stream->index == stream->size) {
        stream->index = 0;
        stream->wrapped++;
    }

    stream->buffer [stream->index++] = value;
}

static void check_buff (int value, void *ctx)
{
    streamer *stream = ctx;

    if (stream->index == stream->size) {
        stream->wrapped++;
        return;
    }

    if (stream->buffer [stream->index] != value)
        if (!stream->byte_errors++)
            stream->first_error = stream->index;

    stream->index++;
}

#ifdef _WIN32

long long DoGetFileSize (FILE *hFile)
{
    LARGE_INTEGER Size;
    HANDLE        fHandle;

    if (hFile == NULL)
        return 0;

    fHandle = (HANDLE)_get_osfhandle(_fileno(hFile));
    if (fHandle == INVALID_HANDLE_VALUE)
        return 0;

    Size.u.LowPart = GetFileSize(fHandle, &Size.u.HighPart);

    if (Size.u.LowPart == INVALID_FILE_SIZE && GetLastError() != NO_ERROR)
        return 0;

    return (long long)Size.QuadPart;
}

#else

long long DoGetFileSize (FILE *hFile)
{
    struct stat statbuf;

    if (!hFile || fstat (fileno (hFile), &statbuf) || !S_ISREG(statbuf.st_mode))
        return 0;

    return (long long) statbuf.st_size;
}

#endif

int main (int argc, char **argv)
{
    int index, checked = 0, tests = 0, skipped = 0, errors = 0;
    int set_maxbits = 0, quiet_mode = 0, exhaustive_mode = 0;
    long long total_input_bytes = 0, total_output_bytes = 0;
    streamer reader, writer, checker;

    memset (&reader, 0, sizeof (reader));
    memset (&writer, 0, sizeof (writer));
    memset (&checker, 0, sizeof (checker));

    if (argc < 2) {
        printf ("%s", usage);
        return 0;
    }

    for (index = 1; index < argc; ++index) {
        const char *filename = argv [index];
        int test_size, bytes_read, maxbits;
        unsigned char *file_buffer;
        long long file_size;
        FILE *infile;

        if (!strcmp (filename, "-q")) {
            quiet_mode = 1;
            continue;
        }

        if (!strcmp (filename, "-e")) {
            exhaustive_mode = 1;
            continue;
        }

        if (!strcmp (filename, "-f")) {
            writer.fuzz_testing = 1;
            continue;
        }

        if (strlen (filename) == 2 && filename [0] == '-' && filename [1] >= '0' && filename [1] <= '8') {
            if (filename [1] > '0')
                set_maxbits = filename [1] - '0' + 8;
            else
                set_maxbits = 0;

            continue;
        }

        infile = fopen (filename, "rb");

        if (!infile) {
            printf ("\ncan't open file %s!\n", filename);
            skipped++;
            continue;
        }

        file_size = DoGetFileSize (infile);

        if (!file_size) {
            printf ("\ncan't get file size of %s (may be zero)!\n", filename);
            skipped++;
            continue;
        }

        if (file_size > 1024LL * 1024LL * 1024LL) {
            printf ("\nfile %s is too big!\n", filename);
            skipped++;
            continue;
        }

        file_buffer = malloc (file_size);
        writer.size = (unsigned int)(file_size * 2 + 10);
        writer.buffer = malloc (writer.size);

        if (!file_buffer || !writer.buffer) {
            printf ("\nfile %s is too big!\n", filename);
            if (writer.buffer) free (writer.buffer);
            if (file_buffer) free (file_buffer);
            skipped++;
            continue;
        }

        bytes_read = fread (file_buffer, 1, (int) file_size, infile);
        fclose (infile);

        if (bytes_read != (int) file_size) {
            printf ("\nfile %s could not be read!\n", filename);
            free (writer.buffer);
            free (file_buffer);
            skipped++;
            continue;
        }

        if (!quiet_mode)
            printf ("\n");

        test_size = file_size;
        checked++;

        do {
            for (maxbits = set_maxbits ? set_maxbits : 9; maxbits <= (set_maxbits ? set_maxbits : 16); ++maxbits) {
                int res, got_error = 0;

                reader.buffer = file_buffer + (file_size - test_size) / 2;
                reader.size = test_size;

                reader.index = writer.index = writer.wrapped = 0;

                if (lzw_compress (write_buff, &writer, read_buff, &reader, maxbits)) {
                    printf ("\nlzw_compress() returned error on file %s, maxbits = %d\n", filename, maxbits);
                    errors++;
                    continue;
                }

                if (writer.wrapped) {
                    printf ("\nover 100%% inflation on file %s, maxbits = %d!\n", filename, maxbits);
                    errors++;
                    continue;
                }

                checker.buffer = reader.buffer;
                checker.size = reader.size;
                checker.wrapped = checker.byte_errors = checker.index = 0;

                reader.buffer = writer.buffer;
                reader.size = writer.index;
                reader.index = 0;

                res = lzw_decompress (check_buff, &checker, read_buff, &reader);

                reader.buffer = checker.buffer;
                reader.size = checker.size;

                got_error = res || checker.index != checker.size || checker.wrapped || checker.byte_errors;

                if (!quiet_mode || got_error)
                    printf ("file %s, maxbits = %2d: %u bytes --> %u bytes, %.2f%%\n", filename, maxbits,
                        reader.size, writer.index, writer.index * 100.0 / reader.size);

                if (got_error) {
                    if (res)
                        printf ("decompressor returned an error\n");

                    if (!checker.index)
                        printf ("decompression didn't generate any data\n");
                    else if (checker.index != checker.size)
                        printf ("decompression terminated %u bytes early\n", checker.size - checker.index);
                    else if (checker.wrapped)
                        printf ("decompression generated %u extra bytes\n", checker.wrapped);

                    if (checker.byte_errors)
                        printf ("there were %u byte data errors starting at index %u\n",
                            checker.byte_errors, checker.first_error);
                    else if (checker.index != checker.size || checker.wrapped)
                        printf ("(but the data generated was all correct)\n");

                    printf ("\n");
                    errors++;
                }
                else {
                    total_input_bytes += reader.size;
                    total_output_bytes += writer.index;
                }

                tests++;

                if (exhaustive_mode)
                   test_size -= (test_size + 98) / 100;
            }

        } while (exhaustive_mode && test_size > 1 && test_size > file_size / 100);

        free (writer.buffer);
        free (file_buffer);
    }

    if (errors)
        printf ("\n***** %d errors detected in %d tests using %d files (%d skipped) *****\n\n", errors, tests, checked, skipped);
    else {
        printf ("\nsuccessfully ran %d tests using %d files (%d skipped) with no errors detected\n", tests, checked, skipped);
        printf ("cumulative results: %llu bytes --> %llu bytes, %.2f%%\n\n", total_input_bytes, total_output_bytes,
            total_output_bytes * 100.0 / total_input_bytes);
    }

    return errors;
}