text: #include <stdint.h>
  #include <ctype.h>
  #include <assert.h>
  
  #include "heatshrink_encoder.h"
  #include "heatshrink_decoder.h"
  #include "greatest.h"
  
  #if !HEATSHRINK_DYNAMIC_ALLOC
  #error Must set HEATSHRINK_DYNAMIC_ALLOC to 1 for dynamic allocation test suite.
  #endif
  
  SUITE(encoding);
  SUITE(decoding);
  SUITE(integration);
  
  #ifdef HEATSHRINK_HAS_THEFT
  SUITE(properties);
  #endif
  
  static void dump_buf(char *name, uint8_t *buf, uint16_t count) {
      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 : '.');
      }
  }
  
  TEST encoder_alloc_should_reject_invalid_arguments(void) {
      ASSERT_EQ(NULL, heatshrink_encoder_alloc(
              HEATSHRINK_MIN_WINDOW_BITS - 1, 8));
      ASSERT_EQ(NULL, heatshrink_encoder_alloc(
              HEATSHRINK_MAX_WINDOW_BITS + 1, 8));
      ASSERT_EQ(NULL, heatshrink_encoder_alloc(8, HEATSHRINK_MIN_LOOKAHEAD_BITS - 1));
      ASSERT_EQ(NULL, heatshrink_encoder_alloc(8, 9));
      PASS();
  }
  
  TEST encoder_sink_should_reject_nulls(void) {
      heatshrink_encoder *hse = heatshrink_encoder_alloc(8, 7);
      uint8_t input[] = {'f', 'o', 'o'};
      size_t input_size = 0;
      ASSERT(hse);
      ASSERT_EQ(HSER_SINK_ERROR_NULL, heatshrink_encoder_sink(NULL, input, 3, &input_size));
      ASSERT_EQ(HSER_SINK_ERROR_NULL, heatshrink_encoder_sink(hse, NULL, 3, &input_size));
      ASSERT_EQ(HSER_SINK_ERROR_NULL, heatshrink_encoder_sink(hse, input, 3, NULL));
      heatshrink_encoder_free(hse);
      PASS();
  }
  
  TEST encoder_poll_should_reject_nulls(void) {
      heatshrink_encoder *hse = heatshrink_encoder_alloc(8, 7);
      uint8_t output[256];
      size_t output_size = 0;
      ASSERT_EQ(HSER_POLL_ERROR_NULL, heatshrink_encoder_poll(NULL,
              output, 256, &output_size));
      ASSERT_EQ(HSER_POLL_ERROR_NULL, heatshrink_encoder_poll(hse,
              NULL, 256, &output_size));
      ASSERT_EQ(HSER_POLL_ERROR_NULL, heatshrink_encoder_poll(hse,
              output, 256, NULL));
  
      heatshrink_encoder_free(hse);
      PASS();
  }
  
  TEST encoder_finish_should_reject_nulls(void) {
      ASSERT_EQ(HSER_FINISH_ERROR_NULL, heatshrink_encoder_finish(NULL));
      PASS();
  }
  
  TEST encoder_sink_should_accept_input_when_it_will_fit(void) {
      heatshrink_encoder *hse = heatshrink_encoder_alloc(8, 7);
      ASSERT(hse);
      uint8_t input[256];
      size_t bytes_copied = 0;
      memset(input, '*', 256);
      ASSERT_EQ(HSER_SINK_OK, heatshrink_encoder_sink(hse,
              input, 256, &bytes_copied));
      ASSERT_EQ(256, bytes_copied);
  
      heatshrink_encoder_free(hse);
      PASS();
  }
  
  TEST encoder_sink_should_accept_partial_input_when_some_will_fit(void) {
      heatshrink_encoder *hse = heatshrink_encoder_alloc(8, 7);
      ASSERT(hse);
      uint8_t input[512];
      size_t bytes_copied = 0;
      memset(input, '*', 512);
      ASSERT_EQ(HSER_SINK_OK, heatshrink_encoder_sink(hse,
              input, 512, &bytes_copied));
      ASSERT_EQ(256, bytes_copied);
  
      heatshrink_encoder_free(hse);
      PASS();
  }
  
  TEST encoder_poll_should_indicate_when_no_input_is_provided(void) {
      heatshrink_encoder *hse = heatshrink_encoder_alloc(8, 7);
      uint8_t output[512];
      size_t output_size = 0;
  
      HSE_poll_res res = heatshrink_encoder_poll(hse,
          output, 512, &output_size);
      ASSERT_EQ(HSER_POLL_EMPTY, res);
      heatshrink_encoder_free(hse);
      PASS();
  }
  
  TEST encoder_should_emit_data_without_repetitions_as_literal_sequence(void) {
      heatshrink_encoder *hse = heatshrink_encoder_alloc(8, 7);
      ASSERT(hse);
      uint8_t input[5];
      uint8_t output[1024];
      size_t copied = 0;
      uint8_t expected[] = { 0x80, 0x40, 0x60, 0x50, 0x38, 0x20 };
  
      for (int i=0; i<5; i++) { input[i] = i; }
      memset(output, 0, 1024);
      ASSERT_EQ(HSER_SINK_OK, heatshrink_encoder_sink(hse, input, 5, &copied));
      ASSERT_EQ(5, copied);
      
      /* Should get no output yet, since encoder doesn't know input is complete. */
      copied = 0;
      HSE_poll_res pres = heatshrink_encoder_poll(hse, output, 1024, &copied);
      ASSERT_EQ(HSER_POLL_EMPTY, pres);
      ASSERT_EQ(0, copied);
  
      /* Mark input stream as done, to force small input to be processed. */
      HSE_finish_res fres = heatshrink_encoder_finish(hse);
      ASSERT_EQ(HSER_FINISH_MORE, fres);
  
      pres = heatshrink_encoder_poll(hse, output, 1024, &copied);
      ASSERT_EQ(HSER_POLL_EMPTY, pres);
  
      for (size_t i=0; i<sizeof(expected); i++) {
          ASSERT_EQ(expected[i], output[i]);
      }
  
      ASSERT_EQ(HSER_FINISH_DONE, heatshrink_encoder_finish(hse));
      
      heatshrink_encoder_free(hse);
      PASS();
  }
  
  TEST encoder_should_emit_series_of_same_byte_as_literal_then_backref(void) {
      heatshrink_encoder *hse = heatshrink_encoder_alloc(8, 7);
      ASSERT(hse);
      uint8_t input[5];
      uint8_t output[1024];
      size_t copied = 0;
      uint8_t expected[] = {0xb0, 0x80, 0x01, 0x80};
  
      for (int i=0; i<5; i++) { input[i] = 'a'; } /* "aaaaa" */
      memset(output, 0, 1024);
      ASSERT_EQ(HSER_SINK_OK, heatshrink_encoder_sink(hse, input, 5, &copied));
      ASSERT_EQ(5, copied);
      
      /* Should get no output yet, since encoder doesn't know input is complete. */
      copied = 0;
      HSE_poll_res pres = heatshrink_encoder_poll(hse, output, 1024, &copied);
      ASSERT_EQ(HSER_POLL_EMPTY, pres);
      ASSERT_EQ(0, copied);
  
      /* Mark input stream as done, to force small input to be processed. */
      HSE_finish_res fres = heatshrink_encoder_finish(hse);
      ASSERT_EQ(HSER_FINISH_MORE, fres);
  
      pres = heatshrink_encoder_poll(hse, output, 1024, &copied);
      ASSERT_EQ(HSER_POLL_EMPTY, pres);
      ASSERT_EQ(4, copied);
      if (0) dump_buf("output", output, copied);
      for (size_t i=0; i<copied; i++) ASSERT_EQ(expected[i], output[i]);
  
      ASSERT_EQ(HSER_FINISH_DONE, heatshrink_encoder_finish(hse));
      
      heatshrink_encoder_free(hse);
      PASS();
  }
  
  TEST encoder_poll_should_detect_repeated_substring(void) {
      heatshrink_encoder *hse = heatshrink_encoder_alloc(8, 3);
      uint8_t input[] = {'a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'};
      uint8_t output[1024];
      uint8_t expected[] = {0xb0, 0xd8, 0xac, 0x76, 0x40, 0x1b };
  
      size_t copied = 0;
      memset(output, 0, 1024);
      HSE_sink_res sres = heatshrink_encoder_sink(hse,
          input, sizeof(input), &copied);
      ASSERT_EQ(HSER_SINK_OK, sres);
      ASSERT_EQ(sizeof(input), copied);
  
      HSE_finish_res fres = heatshrink_encoder_finish(hse);
      ASSERT_EQ(HSER_FINISH_MORE, fres);
  
      ASSERT_EQ(HSER_POLL_EMPTY, heatshrink_encoder_poll(hse, output, 1024, &copied));
      fres = heatshrink_encoder_finish(hse);
      ASSERT_EQ(HSER_FINISH_DONE, fres);
  
      if (0) dump_buf("output", output, copied);
      ASSERT_EQ(sizeof(expected), copied);
      for (size_t i=0; i<sizeof(expected); i++) ASSERT_EQ(expected[i], output[i]);
      heatshrink_encoder_free(hse);
      PASS();
  }
  
  TEST encoder_poll_should_detect_repeated_substring_and_preserve_trailing_literal(void) {
      heatshrink_encoder *hse = heatshrink_encoder_alloc(8, 3);
      uint8_t input[] = {'a', 'b', 'c', 'd', 'a', 'b', 'c', 'd', 'e'};
      uint8_t output[1024];
      uint8_t expected[] = {0xb0, 0xd8, 0xac, 0x76, 0x40, 0x1b, 0xb2, 0x80 };
      size_t copied = 0;
      memset(output, 0, 1024);
      HSE_sink_res sres = heatshrink_encoder_sink(hse,
          input, sizeof(input), &copied);
      ASSERT_EQ(HSER_SINK_OK, sres);
      ASSERT_EQ(sizeof(input), copied);
  
      HSE_finish_res fres = heatshrink_encoder_finish(hse);
      ASSERT_EQ(HSER_FINISH_MORE, fres);
  
      ASSERT_EQ(HSER_POLL_EMPTY, heatshrink_encoder_poll(hse, output, 1024, &copied));
      fres = heatshrink_encoder_finish(hse);
      ASSERT_EQ(HSER_FINISH_DONE, fres);
  
      if (0) dump_buf("output", output, copied);
      ASSERT_EQ(sizeof(expected), copied);
      for (size_t i=0; i<sizeof(expected); i++) ASSERT_EQ(expected[i], output[i]);
      heatshrink_encoder_free(hse);
      PASS();
  }
  
  SUITE(encoding) {
      RUN_TEST(encoder_alloc_should_reject_invalid_arguments);
  
      RUN_TEST(encoder_sink_should_reject_nulls);
      RUN_TEST(encoder_sink_should_accept_input_when_it_will_fit);
      RUN_TEST(encoder_sink_should_accept_partial_input_when_some_will_fit);
  
      RUN_TEST(encoder_poll_should_reject_nulls);
      RUN_TEST(encoder_poll_should_indicate_when_no_input_is_provided);
  
      RUN_TEST(encoder_finish_should_reject_nulls);
  
      RUN_TEST(encoder_should_emit_data_without_repetitions_as_literal_sequence);
      RUN_TEST(encoder_should_emit_series_of_same_byte_as_literal_then_backref);
      RUN_TEST(encoder_poll_should_detect_repeated_substring);
      RUN_TEST(encoder_poll_should_detect_repeated_substring_and_preserve_trailing_literal);
  }
  
  TEST decoder_alloc_should_reject_excessively_small_window(void) {
      ASSERT_EQ(NULL, heatshrink_decoder_alloc(256,
              HEATSHRINK_MIN_WINDOW_BITS - 1, 4));
      PASS();
  }
  
  TEST decoder_alloc_should_reject_zero_byte_input_buffer(void) {
      ASSERT_EQ(NULL, heatshrink_decoder_alloc(0,
              HEATSHRINK_MIN_WINDOW_BITS, 4));
      PASS();
  }
  
  TEST decoder_sink_should_reject_null_hsd_pointer(void) {
      uint8_t input[] = {0,1,2,3,4,5};
      size_t count = 0;
      ASSERT_EQ(HSDR_SINK_ERROR_NULL, heatshrink_decoder_sink(NULL, input, 6, &count));
      PASS();
  }
  
  TEST decoder_sink_should_reject_null_input_pointer(void) {
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256,
          HEATSHRINK_MIN_WINDOW_BITS, 4);
      size_t count = 0;
      ASSERT_EQ(HSDR_SINK_ERROR_NULL, heatshrink_decoder_sink(hsd, NULL, 6, &count));
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_sink_should_reject_null_count_pointer(void) {
      uint8_t input[] = {0,1,2,3,4,5};
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256,
          HEATSHRINK_MIN_WINDOW_BITS, 4);
      ASSERT_EQ(HSDR_SINK_ERROR_NULL, heatshrink_decoder_sink(hsd, input, 6, NULL));
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_sink_should_reject_excessively_large_input(void) {
      uint8_t input[] = {0,1,2,3,4,5};
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(1,
          HEATSHRINK_MIN_WINDOW_BITS, 4);
      size_t count = 0;
      // Sink as much as will fit
      HSD_sink_res res = heatshrink_decoder_sink(hsd, input, 6, &count);
      ASSERT_EQ(HSDR_SINK_OK, res);
      ASSERT_EQ(1, count);
  
      // And now, no more should fit.
      res = heatshrink_decoder_sink(hsd, &input[count], sizeof(input) - count, &count);
      ASSERT_EQ(HSDR_SINK_FULL, res);
      ASSERT_EQ(0, count);
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_sink_should_sink_data_when_preconditions_hold(void) {
      uint8_t input[] = {0,1,2,3,4,5};
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256,
          HEATSHRINK_MIN_WINDOW_BITS, 4);
      size_t count = 0;
      HSD_sink_res res = heatshrink_decoder_sink(hsd, input, 6, &count);
      ASSERT_EQ(HSDR_SINK_OK, res);
      ASSERT_EQ(hsd->input_size, 6);
      ASSERT_EQ(hsd->input_index, 0);
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_poll_should_return_empty_if_empty(void) {
      uint8_t output[256];
      size_t out_sz = 0;
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256,
          HEATSHRINK_MIN_WINDOW_BITS, 4);
      HSD_poll_res res = heatshrink_decoder_poll(hsd, output, 256, &out_sz);
      ASSERT_EQ(HSDR_POLL_EMPTY, res);
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_poll_should_reject_null_hsd(void) {
      uint8_t output[256];
      size_t out_sz = 0;
      HSD_poll_res res = heatshrink_decoder_poll(NULL, output, 256, &out_sz);
      ASSERT_EQ(HSDR_POLL_ERROR_NULL, res);
      PASS();
  }
  
  TEST decoder_poll_should_reject_null_output_buffer(void) {
      size_t out_sz = 0;
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256,
          HEATSHRINK_MIN_WINDOW_BITS, 4);
      HSD_poll_res res = heatshrink_decoder_poll(hsd, NULL, 256, &out_sz);
      ASSERT_EQ(HSDR_POLL_ERROR_NULL, res);
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_poll_should_reject_null_output_size_pointer(void) {
      uint8_t output[256];
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256,
          HEATSHRINK_MIN_WINDOW_BITS, 4);
      HSD_poll_res res = heatshrink_decoder_poll(hsd, output, 256, NULL);
      ASSERT_EQ(HSDR_POLL_ERROR_NULL, res);
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_poll_should_expand_short_literal(void) {
      uint8_t input[] = {0xb3, 0x5b, 0xed, 0xe0 }; //"foo"
      uint8_t output[4];
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256, 7, 3);
      size_t count = 0;
  
      HSD_sink_res sres = heatshrink_decoder_sink(hsd, input, sizeof(input), &count);
      ASSERT_EQ(HSDR_SINK_OK, sres);
  
      size_t out_sz = 0;
      HSD_poll_res pres = heatshrink_decoder_poll(hsd, output, 4, &out_sz);
      ASSERT_EQ(HSDR_POLL_EMPTY, pres);
      ASSERT_EQ(3, out_sz);
      ASSERT_EQ('f', output[0]);
      ASSERT_EQ('o', output[1]);
      ASSERT_EQ('o', output[2]);
  
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_poll_should_expand_short_literal_and_backref(void) {
      uint8_t input[] = {0xb3, 0x5b, 0xed, 0xe0, 0x40, 0x80}; //"foofoo"
      uint8_t output[6];
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256, 7, 7);
      memset(output, 0, sizeof(*output));
      size_t count = 0;
      
      HSD_sink_res sres = heatshrink_decoder_sink(hsd, input, sizeof(input), &count);
      ASSERT_EQ(HSDR_SINK_OK, sres);
  
      size_t out_sz = 0;
      (void)heatshrink_decoder_poll(hsd, output, 6, &out_sz);
  
      if (0) dump_buf("output", output, out_sz);
      ASSERT_EQ(6, out_sz);
      ASSERT_EQ('f', output[0]);
      ASSERT_EQ('o', output[1]);
      ASSERT_EQ('o', output[2]);
      ASSERT_EQ('f', output[3]);
      ASSERT_EQ('o', output[4]);
      ASSERT_EQ('o', output[5]);
  
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_poll_should_expand_short_self_overlapping_backref(void) {
      /* "aaaaa" == (literal, 1), ('a'), (backref, 1 back, 4 bytes) */
      uint8_t input[] = {0xb0, 0x80, 0x01, 0x80};
      uint8_t output[6];
      uint8_t expected[] = {'a', 'a', 'a', 'a', 'a'};
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256, 8, 7);
      size_t count = 0;
      
      HSD_sink_res sres = heatshrink_decoder_sink(hsd, input, sizeof(input), &count);
      ASSERT_EQ(HSDR_SINK_OK, sres);
  
      size_t out_sz = 0;
      (void)heatshrink_decoder_poll(hsd, output, sizeof(output), &out_sz);
  
      if (0) dump_buf("output", output, out_sz);
      ASSERT_EQ(sizeof(expected), out_sz);
      for (size_t i=0; i<sizeof(expected); i++) ASSERT_EQ(expected[i], output[i]);
  
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_poll_should_suspend_if_out_of_space_in_output_buffer_during_literal_expansion(void) {
      uint8_t input[] = {0xb3, 0x5b, 0xed, 0xe0, 0x40, 0x80};
      uint8_t output[1];
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256, 7, 7);
      size_t count = 0;
      
      HSD_sink_res sres = heatshrink_decoder_sink(hsd, input, sizeof(input), &count);
      ASSERT_EQ(HSDR_SINK_OK, sres);
  
      size_t out_sz = 0;
      HSD_poll_res pres = heatshrink_decoder_poll(hsd, output, 1, &out_sz);
      ASSERT_EQ(HSDR_POLL_MORE, pres);
      ASSERT_EQ(1, out_sz);
      ASSERT_EQ('f', output[0]);
  
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_poll_should_suspend_if_out_of_space_in_output_buffer_during_backref_expansion(void) {
      uint8_t input[] = {0xb3, 0x5b, 0xed, 0xe0, 0x40, 0x80}; //"foofoo"
      uint8_t output[4];
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256, 7, 7);
      memset(output, 0, sizeof(*output));
      size_t count = 0;
      
      HSD_sink_res sres = heatshrink_decoder_sink(hsd, input, 6, &count);
      ASSERT_EQ(HSDR_SINK_OK, sres);
  
      size_t out_sz = 0;
      HSD_poll_res pres = heatshrink_decoder_poll(hsd, output, 4, &out_sz);
      ASSERT_EQ(HSDR_POLL_MORE, pres);
      ASSERT_EQ(4, out_sz);
      ASSERT_EQ('f', output[0]);
      ASSERT_EQ('o', output[1]);
      ASSERT_EQ('o', output[2]);
      ASSERT_EQ('f', output[3]);
  
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_poll_should_expand_short_literal_and_backref_when_fed_input_byte_by_byte(void) {
      uint8_t input[] = {0xb3, 0x5b, 0xed, 0xe0, 0x40, 0x80}; //"foofoo"
      uint8_t output[7];
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256, 7, 7);
      memset(output, 0, sizeof(*output));
      size_t count = 0;
      
      HSD_sink_res sres;
      for (int i=0; i<6; i++) {
          sres = heatshrink_decoder_sink(hsd, &input[i], 1, &count);
          ASSERT_EQ(HSDR_SINK_OK, sres);
      }
      heatshrink_decoder_finish(hsd);
  
      size_t out_sz = 0;
      HSD_poll_res pres = heatshrink_decoder_poll(hsd, output, 7, &out_sz);
      ASSERT_EQ(6, out_sz);
      ASSERT_EQ(HSDR_POLL_EMPTY, pres);
      ASSERT_EQ('f', output[0]);
      ASSERT_EQ('o', output[1]);
      ASSERT_EQ('o', output[2]);
      ASSERT_EQ('f', output[3]);
      ASSERT_EQ('o', output[4]);
      ASSERT_EQ('o', output[5]);
  
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_finish_should_reject_null_input(void) {
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256, 7, 7);
  
      HSD_finish_res exp = HSDR_FINISH_ERROR_NULL;
      ASSERT_EQ(exp, heatshrink_decoder_finish(NULL));
  
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST decoder_finish_should_note_when_done(void) {
      uint8_t input[] = {0xb3, 0x5b, 0xed, 0xe0, 0x40, 0x80}; //"foofoo"
  
      uint8_t output[7];
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256, 7, 7);
      memset(output, 0, sizeof(*output));
      size_t count = 0;
      
      HSD_sink_res sres = heatshrink_decoder_sink(hsd, input, sizeof(input), &count);
      ASSERT_EQ(HSDR_SINK_OK, sres);
  
      size_t out_sz = 0;
      HSD_poll_res pres = heatshrink_decoder_poll(hsd, output, sizeof(output), &out_sz);
      ASSERT_EQ(HSDR_POLL_EMPTY, pres);
      ASSERT_EQ(6, out_sz);
      ASSERT_EQ('f', output[0]);
      ASSERT_EQ('o', output[1]);
      ASSERT_EQ('o', output[2]);
      ASSERT_EQ('f', output[3]);
      ASSERT_EQ('o', output[4]);
      ASSERT_EQ('o', output[5]);
  
      HSD_finish_res fres = heatshrink_decoder_finish(hsd);
      ASSERT_EQ(HSDR_FINISH_DONE, fres);
  
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST gen(void) {
      heatshrink_encoder *hse = heatshrink_encoder_alloc(8, 7);
      uint8_t input[] = {'a', 'a', 'a', 'a', 'a'};
      uint8_t output[1024];
      size_t copied = 0;
      memset(output, 0, 1024);
      HSE_sink_res sres = heatshrink_encoder_sink(hse,
          input, sizeof(input), &copied);
      ASSERT_EQ(HSER_SINK_OK, sres);
      ASSERT_EQ(sizeof(input), copied);
  
      HSE_finish_res fres = heatshrink_encoder_finish(hse);
      ASSERT_EQ(HSER_FINISH_MORE, fres);
  
      ASSERT_EQ(HSER_POLL_EMPTY, heatshrink_encoder_poll(hse, output, 1024, &copied));
      fres = heatshrink_encoder_finish(hse);
      ASSERT_EQ(HSER_FINISH_DONE, fres);
      if (0) {
          printf("{");
          for (size_t i=0; i<copied; i++) printf("0x%02x, ", output[i]);
          printf("}\n");
      }
      heatshrink_encoder_free(hse);
      PASS();
  }
  
  TEST decoder_should_not_get_stuck_with_finish_yielding_MORE_but_0_bytes_output_from_poll(void) {
      uint8_t input[512];
      memset(input, 0xff, 256);
  
      uint8_t output[1024];
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256, 8, 4);
      ASSERT(hsd);
  
      /* Confirm that no byte of trailing context can lead to
       * heatshrink_decoder_finish erroneously returning HSDR_FINISH_MORE
       * when heatshrink_decoder_poll will yield 0 bytes.
       *
       * Before 0.3.1, a final byte of 0xFF could potentially cause
       * this to happen, if at exactly the byte boundary. */
      for (uint16_t byte = 0; byte < 256; byte++) {
          for (int i = 1; i < 512; i++) {
              input[i] = byte;
              heatshrink_decoder_reset(hsd);
              memset(output, 0, sizeof(*output));
              size_t count = 0;
              
              HSD_sink_res sres = heatshrink_decoder_sink(hsd, input, i, &count);
              ASSERT_EQ(HSDR_SINK_OK, sres);
              
              size_t out_sz = 0;
              HSD_poll_res pres = heatshrink_decoder_poll(hsd, output, sizeof(output), &out_sz);
              ASSERT_EQ(HSDR_POLL_EMPTY, pres);
              
              HSD_finish_res fres = heatshrink_decoder_finish(hsd);
              ASSERT_EQ(HSDR_FINISH_DONE, fres);
              input[i] = 0xff;
          }
      }
  
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  SUITE(decoding) {
      RUN_TEST(decoder_alloc_should_reject_excessively_small_window);
      RUN_TEST(decoder_alloc_should_reject_zero_byte_input_buffer);
  
      RUN_TEST(decoder_sink_should_reject_null_hsd_pointer);
      RUN_TEST(decoder_sink_should_reject_null_input_pointer);
      RUN_TEST(decoder_sink_should_reject_null_count_pointer);
      RUN_TEST(decoder_sink_should_reject_excessively_large_input);
      RUN_TEST(decoder_sink_should_sink_data_when_preconditions_hold);
  
      RUN_TEST(gen);
  
      RUN_TEST(decoder_poll_should_return_empty_if_empty);
      RUN_TEST(decoder_poll_should_reject_null_hsd);
      RUN_TEST(decoder_poll_should_reject_null_output_buffer);
      RUN_TEST(decoder_poll_should_reject_null_output_size_pointer);
      RUN_TEST(decoder_poll_should_expand_short_literal);
      RUN_TEST(decoder_poll_should_expand_short_literal_and_backref);
      RUN_TEST(decoder_poll_should_expand_short_self_overlapping_backref);
      RUN_TEST(decoder_poll_should_suspend_if_out_of_space_in_output_buffer_during_literal_expansion);
      RUN_TEST(decoder_poll_should_suspend_if_out_of_space_in_output_buffer_during_backref_expansion);
      RUN_TEST(decoder_poll_should_expand_short_literal_and_backref_when_fed_input_byte_by_byte);
  
      RUN_TEST(decoder_finish_should_reject_null_input);
      RUN_TEST(decoder_finish_should_note_when_done);
  
      // Regressions
      RUN_TEST(decoder_should_not_get_stuck_with_finish_yielding_MORE_but_0_bytes_output_from_poll);
  }
  
  typedef struct {
      uint8_t log_lvl;
      uint8_t window_sz2;
      uint8_t lookahead_sz2;
      size_t decoder_input_buffer_size;
  } cfg_info;
  
  static int compress_and_expand_and_check(uint8_t *input, uint32_t input_size, cfg_info *cfg) {
      heatshrink_encoder *hse = heatshrink_encoder_alloc(cfg->window_sz2,
          cfg->lookahead_sz2);
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(cfg->decoder_input_buffer_size,
          cfg->window_sz2, cfg->lookahead_sz2);
      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 (cfg->log_lvl > 1) {
          printf("\n^^ COMPRESSING\n");
          dump_buf("input", input, input_size);
      }
  
      size_t sunk = 0;
      size_t polled = 0;
      while (sunk < input_size) {
          ASSERT(heatshrink_encoder_sink(hse, &input[sunk], input_size - sunk, &count) >= 0);
          sunk += count;
          if (cfg->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 (cfg->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 (cfg->log_lvl > 0) printf("in: %u compressed: %zu ", input_size, polled);
      size_t compressed_size = polled;
      sunk = 0;
      polled = 0;
      
      if (cfg->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 (cfg->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);
              ASSERT(count > 0);
              polled += count;
              if (cfg->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) {
              printf("\nExpected %zd, got %zu\n", (size_t)input_size, polled);
              FAILm("Decompressed data is larger than original input");
          }
      }
      if (cfg->log_lvl > 0) printf("decompressed: %zu\n", polled);
      if (polled != input_size) {
          FAILm("Decompressed length does not match original input length");
      }
  
      if (cfg->log_lvl > 1) dump_buf("decomp", decomp, polled);
      for (uint32_t i=0; i<input_size; i++) {
          if (input[i] != decomp[i]) {
              printf("*** mismatch at %d\n", i);
              if (0) {
                  for (uint32_t j=0; j<=/*i*/ input_size; j++) {
                      printf("in[%d] == 0x%02x ('%c') => out[%d] == 0x%02x ('%c')  %c\n",
                          j, input[j], isprint(input[j]) ? input[j] : '.',
                          j, decomp[j], isprint(decomp[j]) ? decomp[j] : '.',
                          input[j] == decomp[j] ? ' ' : 'X');
                  }
              }
          }
          ASSERT_EQ(input[i], decomp[i]);
      }
      free(comp);
      free(decomp);
      heatshrink_encoder_free(hse);
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST data_without_duplication_should_match(void) {
      uint8_t input[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
                         'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
                         's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
      cfg_info cfg;
      cfg.log_lvl = 0;
      cfg.window_sz2 = 8;
      cfg.lookahead_sz2 = 3;
      cfg.decoder_input_buffer_size = 256;
      return compress_and_expand_and_check(input, sizeof(input), &cfg);
  }
  
  TEST data_with_simple_repetition_should_compress_and_decompress_properly(void) {
      uint8_t input[] = {'a', 'b', 'c', 'a', 'b', 'c', 'd', 'a', 'b',
                         'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e', 'f',
                         'a', 'b', 'c', 'd', 'e', 'f', 'g', 'a', 'b',
                         'c', 'd', 'e', 'f', 'g', 'h'};
      cfg_info cfg;
      cfg.log_lvl = 0;
      cfg.window_sz2 = 8;
      cfg.lookahead_sz2 = 3;
      cfg.decoder_input_buffer_size = 256;
      return compress_and_expand_and_check(input, sizeof(input), &cfg);
  }
  
  TEST data_without_duplication_should_match_with_absurdly_tiny_buffers(void) {
      heatshrink_encoder *hse = heatshrink_encoder_alloc(8, 3);
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256, 8, 3);
      uint8_t input[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
                         'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
                         's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
      uint8_t comp[60];
      uint8_t decomp[60];
      size_t count = 0;
      int log = 0;
  
      if (log) dump_buf("input", input, sizeof(input));
      for (uint32_t i=0; i<sizeof(input); i++) {
          ASSERT(heatshrink_encoder_sink(hse, &input[i], 1, &count) >= 0);
      }
      ASSERT_EQ(HSER_FINISH_MORE, heatshrink_encoder_finish(hse));
  
      size_t packed_count = 0;
      do {
          ASSERT(heatshrink_encoder_poll(hse, &comp[packed_count], 1, &count) >= 0);
          packed_count += count;
      } while (heatshrink_encoder_finish(hse) == HSER_FINISH_MORE);
  
      if (log) dump_buf("comp", comp, packed_count);
      for (uint32_t i=0; i<packed_count; i++) {
          HSD_sink_res sres = heatshrink_decoder_sink(hsd, &comp[i], 1, &count);
          //printf("sres is %d\n", sres);
          ASSERT(sres >= 0);
      }
  
      for (uint32_t i=0; i<sizeof(input); i++) {
          ASSERT(heatshrink_decoder_poll(hsd, &decomp[i], 1, &count) >= 0);
      }
  
      if (log) dump_buf("decomp", decomp, sizeof(input));
      for (uint32_t i=0; i<sizeof(input); i++) ASSERT_EQ(input[i], decomp[i]);
      heatshrink_encoder_free(hse);
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  TEST data_with_simple_repetition_should_match_with_absurdly_tiny_buffers(void) {
      heatshrink_encoder *hse = heatshrink_encoder_alloc(8, 3);
      heatshrink_decoder *hsd = heatshrink_decoder_alloc(256, 8, 3);
      uint8_t input[] = {'a', 'b', 'c', 'a', 'b', 'c', 'd', 'a', 'b',
                         'c', 'd', 'e', 'a', 'b', 'c', 'd', 'e', 'f',
                         'a', 'b', 'c', 'd', 'e', 'f', 'g', 'a', 'b',
                         'c', 'd', 'e', 'f', 'g', 'h'};
      uint8_t comp[60];
      uint8_t decomp[60];
      size_t count = 0;
      int log = 0;
  
      if (log) dump_buf("input", input, sizeof(input));
      for (uint32_t i=0; i<sizeof(input); i++) {
          ASSERT(heatshrink_encoder_sink(hse, &input[i], 1, &count) >= 0);
      }
      ASSERT_EQ(HSER_FINISH_MORE, heatshrink_encoder_finish(hse));
  
      size_t packed_count = 0;
      do {
          ASSERT(heatshrink_encoder_poll(hse, &comp[packed_count], 1, &count) >= 0);
          packed_count += count;
      } while (heatshrink_encoder_finish(hse) == HSER_FINISH_MORE);
  
      if (log) dump_buf("comp", comp, packed_count);
      for (uint32_t i=0; i<packed_count; i++) {
          HSD_sink_res sres = heatshrink_decoder_sink(hsd, &comp[i], 1, &count);
          //printf("sres is %d\n", sres);
          ASSERT(sres >= 0);
      }
  
      for (uint32_t i=0; i<sizeof(input); i++) {
          ASSERT(heatshrink_decoder_poll(hsd, &decomp[i], 1, &count) >= 0);
      }
  
      if (log) dump_buf("decomp", decomp, sizeof(input));
      for (uint32_t i=0; i<sizeof(input); i++) ASSERT_EQ(input[i], decomp[i]);
      heatshrink_encoder_free(hse);
      heatshrink_decoder_free(hsd);
      PASS();
  }
  
  static void fill_with_pseudorandom_letters(uint8_t *buf, uint32_t size, uint32_t seed) {
      uint64_t rn = 9223372036854775783; /* prime under 2^64 */
      for (uint32_t i=0; i<size; i++) {
          rn = rn*seed + seed;
          buf[i] = (rn % 26) + 'a';
      }
  }
  
  TEST pseudorandom_data_should_match(uint32_t size, uint32_t seed, cfg_info *cfg) {
      uint8_t input[size];
      if (cfg->log_lvl > 0) {
          printf("\n-- size %u, seed %u, input buf %zu\n",
              size, seed, cfg->decoder_input_buffer_size);
      }
      fill_with_pseudorandom_letters(input, size, seed);
      return compress_and_expand_and_check(input, size, cfg);
  }
  
  TEST small_input_buffer_should_not_impact_decoder_correctness(void) {
      int size = 5;
      uint8_t input[size];
      cfg_info cfg;
      cfg.log_lvl = 0;
      cfg.window_sz2 = 8;
      cfg.lookahead_sz2 = 3;
      cfg.decoder_input_buffer_size = 5;
      for (uint16_t i=0; i<size; i++) input[i] = 'a' + (i % 26);
      if (compress_and_expand_and_check(input, size, &cfg) != 0) return -1;
      PASS();
  }
  
  TEST regression_backreference_counters_should_not_roll_over(void) {
      /* Searching was scanning the entire context buffer, not just
       * the maximum range addressable by the backref index.*/
      uint32_t size = 337;
      uint32_t seed = 3;
      uint8_t input[size];
      fill_with_pseudorandom_letters(input, size, seed);
      cfg_info cfg;
      cfg.log_lvl = 0;
      cfg.window_sz2 = 8;
      cfg.lookahead_sz2 = 3;
      cfg.decoder_input_buffer_size = 64; // 1
      return compress_and_expand_and_check(input, size, &cfg);
  }
  
  TEST regression_index_fail(void) {
      /* Failured when indexed, cause unknown.
       *
       * This has something to do with bad data at the very last
       * byte being indexed, due to spillover. */
      uint32_t size = 507;
      uint32_t seed = 3;
      uint8_t input[size];
      fill_with_pseudorandom_letters(input, size, seed);
      cfg_info cfg;
      cfg.log_lvl = 0;
      cfg.window_sz2 = 8;
      cfg.lookahead_sz2 = 3;
      cfg.decoder_input_buffer_size = 64;
      return compress_and_expand_and_check(input, size, &cfg);
  }
  
  TEST sixty_four_k(void) {
      /* Regression: An input buffer of 64k should not cause an
       * overflow that leads to an infinite loop. */
      uint32_t size = 64 * 1024;
      uint32_t seed = 1;
      uint8_t input[size];
      fill_with_pseudorandom_letters(input, size, seed);
      cfg_info cfg;
      cfg.log_lvl = 0;
      cfg.window_sz2 = 8;
      cfg.lookahead_sz2 = 3;
      cfg.decoder_input_buffer_size = 64;
      return compress_and_expand_and_check(input, size, &cfg);
  }
  
  SUITE(integration) {
      RUN_TEST(data_without_duplication_should_match);
      RUN_TEST(data_with_simple_repetition_should_compress_and_decompress_properly);
      RUN_TEST(data_without_duplication_should_match_with_absurdly_tiny_buffers);
      RUN_TEST(data_with_simple_repetition_should_match_with_absurdly_tiny_buffers);
  
      // Regressions from fuzzing
      RUN_TEST(small_input_buffer_should_not_impact_decoder_correctness);
      RUN_TEST(regression_backreference_counters_should_not_roll_over);
      RUN_TEST(regression_index_fail);
      RUN_TEST(sixty_four_k);
  
  #if __STDC_VERSION__ >= 19901L
      printf("\n\nFuzzing (single-byte sizes):\n");
      for (uint8_t lsize=3; lsize < 8; lsize++) {
          for (uint32_t size=1; size < 128*1024L; size <<= 1) {
              if (GREATEST_IS_VERBOSE()) printf(" -- size %u\n", size);
              for (uint16_t ibs=32; ibs<=8192; ibs <<= 1) { /* input buffer size */
                  if (GREATEST_IS_VERBOSE()) printf(" -- input buffer %u\n", ibs);
                  for (uint32_t seed=1; seed<=10; seed++) {
                      if (GREATEST_IS_VERBOSE()) printf(" -- seed %u\n", seed);
                      cfg_info cfg;
                      cfg.log_lvl = 0;
                      cfg.window_sz2 = 8;
                      cfg.lookahead_sz2 = lsize;
                      cfg.decoder_input_buffer_size = ibs;
                      RUN_TESTp(pseudorandom_data_should_match, size, seed, &cfg);
                  }
              }
          }
      }
  
      printf("\nFuzzing (multi-byte sizes):\n");
      for (uint8_t lsize=6; lsize < 9; lsize++) {
          for (uint32_t size=1; size < 128*1024L; size <<= 1) {
              if (GREATEST_IS_VERBOSE()) printf(" -- size %u\n", size);
              for (uint16_t ibs=32; ibs<=8192; ibs <<= 1) { /* input buffer size */
                  if (GREATEST_IS_VERBOSE()) printf(" -- input buffer %u\n", ibs);
                  for (uint32_t seed=1; seed<=10; seed++) {
                      if (GREATEST_IS_VERBOSE()) printf(" -- seed %u\n", seed);
                      cfg_info cfg;
                      cfg.log_lvl = 0;
                      cfg.window_sz2 = 11;
                      cfg.lookahead_sz2 = lsize;
                      cfg.decoder_input_buffer_size = ibs;
                      RUN_TESTp(pseudorandom_data_should_match, size, seed, &cfg);
                  }
              }
          }
      }
  
  #endif
  }
  
  /* Add all the definitions that need to be in the test runner's main file. */
  GREATEST_MAIN_DEFS();
  
  int main(int argc, char **argv) {
      GREATEST_MAIN_BEGIN();      /* command-line arguments, initialization. */
      RUN_SUITE(encoding);
      RUN_SUITE(decoding);
      RUN_SUITE(integration);
      #ifdef HEATSHRINK_HAS_THEFT
      RUN_SUITE(properties);
      #endif
      GREATEST_MAIN_END();        /* display results */
  }
  