test_heatshrink_static.c File Reference

#include <ctype.h>
#include "heatshrink_encoder.h"
#include "heatshrink_decoder.h"
#include "greatest.h"

Include dependency graph for test_heatshrink_static.c:

Go to the source code of this file.

Functions
	SUITE (integration)
static void	fill_with_pseudorandom_letters (uint8_t *buf, uint16_t size, uint32_t seed)
static void	dump_buf (char *name, uint8_t *buf, uint16_t count)
static int	compress_and_expand_and_check (uint8_t *input, uint32_t input_size, int log_lvl)
TEST	pseudorandom_data_should_match (uint32_t size, uint32_t seed)
	GREATEST_MAIN_DEFS ()
int	main (int argc, char **argv)

Variables
static heatshrink_encoder	hse
static heatshrink_decoder	hsd

Function Documentation

compress_and_expand_and_check()

static int compress_and_expand_and_check ( uint8_t *  input, uint32_t  input_size, int  log_lvl  )

static

Definition at line 34 of file test_heatshrink_static.c.

References ASSERT, ASSERT_EQ, dump_buf(), FAILm, free, heatshrink_decoder_finish(), heatshrink_decoder_poll(), heatshrink_decoder_reset(), heatshrink_decoder_sink(), heatshrink_encoder_finish(), heatshrink_encoder_poll(), heatshrink_encoder_reset(), heatshrink_encoder_sink(), HSDR_FINISH_DONE, HSDR_FINISH_MORE, HSDR_POLL_EMPTY, HSDR_POLL_MORE, HSER_FINISH_DONE, HSER_FINISH_MORE, HSER_POLL_EMPTY, HSER_POLL_MORE, isprint, malloc, memset, NULL, PASS, and printf.

Referenced by pseudorandom_data_should_match().

                                                                                           {
    heatshrink_encoder_reset(&hse);
    heatshrink_decoder_reset(&hsd);
    size_t comp_sz = input_size + (input_size/2) + 4;
    size_t decomp_sz = input_size + (input_size/2) + 4;
    uint8_t *comp = malloc(comp_sz);
    uint8_t *decomp = malloc(decomp_sz);
    if (comp == NULL) FAILm("malloc fail");
    if (decomp == NULL) FAILm("malloc fail");
    memset(comp, 0, comp_sz);
    memset(decomp, 0, decomp_sz);

    size_t count = 0;

    if (log_lvl > 1) {
        printf("\n^^ COMPRESSING\n");
        dump_buf("input", input, input_size);
    }

    uint32_t sunk = 0;
    uint32_t polled = 0;
    while (sunk < input_size) {
        ASSERT(heatshrink_encoder_sink(&hse, &input[sunk], input_size - sunk, &count) >= 0);
        sunk += count;
        if (log_lvl > 1) printf("^^ sunk %zd\n", count);
        if (sunk == input_size) {
            ASSERT_EQ(HSER_FINISH_MORE, heatshrink_encoder_finish(&hse));
        }

        HSE_poll_res pres;
        do {                    /* "turn the crank" */
            pres = heatshrink_encoder_poll(&hse, &comp[polled], comp_sz - polled, &count);
            ASSERT(pres >= 0);
            polled += count;
            if (log_lvl > 1) printf("^^ polled %zd\n", count);
        } while (pres == HSER_POLL_MORE);
        ASSERT_EQ(HSER_POLL_EMPTY, pres);
        if (polled >= comp_sz) FAILm("compression should never expand that much");
        if (sunk == input_size) {
            ASSERT_EQ(HSER_FINISH_DONE, heatshrink_encoder_finish(&hse));
        }
    }
    if (log_lvl > 0) printf("in: %u compressed: %u ", input_size, polled);
    uint32_t compressed_size = polled;
    sunk = 0;
    polled = 0;
    
    if (log_lvl > 1) {
        printf("\n^^ DECOMPRESSING\n");
        dump_buf("comp", comp, compressed_size);
    }
    while (sunk < compressed_size) {
        ASSERT(heatshrink_decoder_sink(&hsd, &comp[sunk], compressed_size - sunk, &count) >= 0);
        sunk += count;
        if (log_lvl > 1) printf("^^ sunk %zd\n", count);
        if (sunk == compressed_size) {
            ASSERT_EQ(HSDR_FINISH_MORE, heatshrink_decoder_finish(&hsd));
        }

        HSD_poll_res pres;
        do {
            pres = heatshrink_decoder_poll(&hsd, &decomp[polled],
                decomp_sz - polled, &count);
            ASSERT(pres >= 0);
            polled += count;
            if (log_lvl > 1) printf("^^ polled %zd\n", count);
        } while (pres == HSDR_POLL_MORE);
        ASSERT_EQ(HSDR_POLL_EMPTY, pres);
        if (sunk == compressed_size) {
            HSD_finish_res fres = heatshrink_decoder_finish(&hsd);
            ASSERT_EQ(HSDR_FINISH_DONE, fres);
        }

        if (polled > input_size) {
            FAILm("Decompressed data is larger than original input");
        }
    }
    if (log_lvl > 0) printf("decompressed: %u\n", polled);
    if (polled != input_size) {
        FAILm("Decompressed length does not match original input length");
    }

    if (log_lvl > 1) dump_buf("decomp", decomp, polled);
    for (size_t i=0; i<input_size; i++) {
        if (input[i] != decomp[i]) {
            printf("*** mismatch at %zd\n", i);
            if (0) {
                for (size_t j=0; j<=/*i*/ input_size; j++) {
                    printf("in[%zd] == 0x%02x ('%c') => out[%zd] == 0x%02x ('%c')\n",
                        j, input[j], isprint(input[j]) ? input[j] : '.',
                        j, decomp[j], isprint(decomp[j]) ? decomp[j] : '.');
                }
            }
        }
        ASSERT_EQ(input[i], decomp[i]);
    }
    free(comp);
    free(decomp);
    PASS();
}

Here is the call graph for this function:

Here is the caller graph for this function:

dump_buf()

static void dump_buf ( char *  name, uint8_t *  buf, uint16_t  count  )

static

Definition at line 27 of file test_heatshrink_static.c.

References isprint, and printf.

Referenced by compress_and_expand_and_check().

                                                               {
    for (int i=0; i<count; i++) {
        uint8_t c = (uint8_t)buf[i];
        printf("%s %d: 0x%02x ('%c')\n", name, i, c, isprint(c) ? c : '.');
    }
}

Here is the caller graph for this function:

fill_with_pseudorandom_letters()

static void fill_with_pseudorandom_letters ( uint8_t *  buf, uint16_t  size, uint32_t  seed  )

static

Definition at line 19 of file test_heatshrink_static.c.

Referenced by pseudorandom_data_should_match().

                                                                                       {
    uint64_t rn = 9223372036854775783; /* prime under 2^64 */
    for (int i=0; i<size; i++) {
        rn = rn*seed + seed;
        buf[i] = (rn % 26) + 'a';
    }
}

Here is the caller graph for this function:

GREATEST_MAIN_DEFS()

GREATEST_MAIN_DEFS

(

)

Referenced by SUITE().

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 156 of file test_heatshrink_static.c.

References GREATEST_MAIN_BEGIN, GREATEST_MAIN_END, printf, and RUN_SUITE.

                                {
    GREATEST_MAIN_BEGIN();      /* command-line arguments, initialization. */
    printf("INPUT_BUFFER_SIZE: %u\n", HEATSHRINK_STATIC_INPUT_BUFFER_SIZE);
    printf("WINDOW_BITS: %u\n", HEATSHRINK_STATIC_WINDOW_BITS);
    printf("LOOKAHEAD_BITS: %u\n", HEATSHRINK_STATIC_LOOKAHEAD_BITS);

    printf("sizeof(heatshrink_encoder): %zd\n", sizeof(heatshrink_encoder));
    printf("sizeof(heatshrink_decoder): %zd\n", sizeof(heatshrink_decoder));
    RUN_SUITE(integration);
    GREATEST_MAIN_END();        /* display results */
}

pseudorandom_data_should_match()

TEST pseudorandom_data_should_match	(	uint32_t	size,
		uint32_t	seed
	)

Definition at line 135 of file test_heatshrink_static.c.

References compress_and_expand_and_check(), and fill_with_pseudorandom_letters().

Referenced by SUITE().

                                                                  {
    uint8_t input[size];
    fill_with_pseudorandom_letters(input, size, seed);
    return compress_and_expand_and_check(input, size, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SUITE()

SUITE

(

integration

)

Definition at line 141 of file test_heatshrink_static.c.

References GREATEST_IS_VERBOSE, GREATEST_MAIN_DEFS(), printf, pseudorandom_data_should_match(), and RUN_TESTp.

                   {
#if __STDC_VERSION__ >= 19901L
    for (uint32_t size=1; size < 64*1024; size <<= 1) {
        if (GREATEST_IS_VERBOSE()) printf(" -- size %u\n", size);
            for (uint32_t seed=1; seed<=100; seed++) {
                if (GREATEST_IS_VERBOSE()) printf(" -- seed %u\n", seed);
                RUN_TESTp(pseudorandom_data_should_match, size, seed);
            }
    }
#endif
}

Here is the call graph for this function:

Variable Documentation

hsd

heatshrink_decoder hsd

static

Definition at line 17 of file test_heatshrink_static.c.

Referenced by compress_and_expand_and_check(), data_with_simple_repetition_should_match_with_absurdly_tiny_buffers(), data_without_duplication_should_match_with_absurdly_tiny_buffers(), decode(), decoder_finish_should_note_when_done(), decoder_finish_should_reject_null_input(), decoder_poll_should_expand_short_literal(), decoder_poll_should_expand_short_literal_and_backref(), decoder_poll_should_expand_short_literal_and_backref_when_fed_input_byte_by_byte(), decoder_poll_should_expand_short_self_overlapping_backref(), decoder_poll_should_reject_null_output_buffer(), decoder_poll_should_reject_null_output_size_pointer(), decoder_poll_should_return_empty_if_empty(), decoder_poll_should_suspend_if_out_of_space_in_output_buffer_during_backref_expansion(), decoder_poll_should_suspend_if_out_of_space_in_output_buffer_during_literal_expansion(), decoder_should_not_get_stuck_with_finish_yielding_MORE_but_0_bytes_output_from_poll(), decoder_sink_should_reject_excessively_large_input(), decoder_sink_should_reject_null_count_pointer(), decoder_sink_should_reject_null_input_pointer(), decoder_sink_should_sink_data_when_preconditions_hold(), and heatshrink_decoder_alloc().

hse

heatshrink_encoder hse

static

Definition at line 16 of file test_heatshrink_static.c.

Referenced by compress_and_expand_and_check(), data_with_simple_repetition_should_match_with_absurdly_tiny_buffers(), data_without_duplication_should_match_with_absurdly_tiny_buffers(), encode(), encoder_poll_should_detect_repeated_substring(), encoder_poll_should_detect_repeated_substring_and_preserve_trailing_literal(), encoder_poll_should_indicate_when_no_input_is_provided(), encoder_poll_should_reject_nulls(), encoder_should_emit_data_without_repetitions_as_literal_sequence(), encoder_should_emit_series_of_same_byte_as_literal_then_backref(), encoder_sink_should_accept_input_when_it_will_fit(), encoder_sink_should_accept_partial_input_when_some_will_fit(), encoder_sink_should_reject_nulls(), gen(), heatshrink_encoder_alloc(), and heatshrink_encoder_sink().