tests/tests_deflate_deflateTune.c

#include "unity/unity.h"
#include "zlib.h"
#include <string.h>
#include <stdlib.h>
#include <stdint.h>

/* Access internal state to verify deflateTune() side-effects */
#include "deflate.h"

static void init_stream(z_stream *strm) {
    memset(strm, 0, sizeof(*strm));
    /* Use default allocator and defaults */
    TEST_ASSERT_EQUAL_INT(Z_OK, deflateInit(strm, Z_DEFAULT_COMPRESSION));
}

static void end_stream(z_stream *strm) {
    /* deflateEnd returns Z_OK normally */
    int ret = deflateEnd(strm);
    TEST_ASSERT_TRUE(ret == Z_OK || ret == Z_DATA_ERROR);
}

void setUp(void) {
    /* Setup code here, or leave empty */
}

void tearDown(void) {
    /* Cleanup code here, or leave empty */
}

static void simple_compress_after_tune(z_stream *strm, const unsigned char *in, size_t in_len) {
    /* Compress input after tuning just to ensure stream is usable */
    uLongf bound = deflateBound(strm, (uLong)in_len);
    unsigned char *out = (unsigned char *)malloc(bound);
    TEST_ASSERT_NOT_NULL(out);

    strm->next_in = (Bytef *)in;
    strm->avail_in = (uInt)in_len;
    strm->next_out = out;
    strm->avail_out = (uInt)bound;

    int ret = deflate(strm, Z_FINISH);
    TEST_ASSERT_TRUE(ret == Z_STREAM_END || ret == Z_OK);
    if (ret == Z_OK) {
        /* Finish remaining */
        ret = deflate(strm, Z_FINISH);
        TEST_ASSERT_EQUAL_INT(Z_STREAM_END, ret);
    }

    /* Some output should have been produced, and not exceed bound */
    TEST_ASSERT_LESS_THAN_UINT(bound + 1, strm->total_out + 1); /* sanity check */

    free(out);
}

/* Test cases */

void test_deflateTune_null_stream_returns_stream_error(void) {
    int ret = deflateTune(NULL, 1, 2, 3, 4);
    TEST_ASSERT_EQUAL_INT(Z_STREAM_ERROR, ret);
}

void test_deflateTune_uninitialized_stream_returns_stream_error(void) {
    z_stream strm;
    memset(&strm, 0, sizeof(strm));
    int ret = deflateTune(&strm, 1, 2, 3, 4);
    TEST_ASSERT_EQUAL_INT(Z_STREAM_ERROR, ret);
}

void test_deflateTune_updates_internal_fields_basic(void) {
    z_stream strm;
    init_stream(&strm);

    int good = 5, max_lazy = 6, nice = 100, max_chain = 200;
    int ret = deflateTune(&strm, good, max_lazy, nice, max_chain);
    TEST_ASSERT_EQUAL_INT(Z_OK, ret);

    deflate_state *s = (deflate_state *)strm.state;
    TEST_ASSERT_NOT_NULL(s);

    TEST_ASSERT_EQUAL_UINT((uInt)good, s->good_match);
    TEST_ASSERT_EQUAL_UINT((uInt)max_lazy, s->max_lazy_match);
    TEST_ASSERT_EQUAL_INT(nice, s->nice_match);
    TEST_ASSERT_EQUAL_UINT((uInt)max_chain, s->max_chain_length);

    /* Ensure stream still works */
    const unsigned char sample[] = "hello hello hello\n";
    simple_compress_after_tune(&strm, sample, sizeof(sample) - 1);

    end_stream(&strm);
}

void test_deflateTune_allows_zero_values_and_stream_works(void) {
    z_stream strm;
    init_stream(&strm);

    int ret = deflateTune(&strm, 0, 0, 0, 0);
    TEST_ASSERT_EQUAL_INT(Z_OK, ret);

    deflate_state *s = (deflate_state *)strm.state;
    TEST_ASSERT_NOT_NULL(s);

    TEST_ASSERT_EQUAL_UINT((uInt)0, s->good_match);
    TEST_ASSERT_EQUAL_UINT((uInt)0, s->max_lazy_match);
    TEST_ASSERT_EQUAL_INT(0, s->nice_match);
    TEST_ASSERT_EQUAL_UINT((uInt)0, s->max_chain_length);

    const unsigned char input[] = "abcabcabcabcabcabc";
    simple_compress_after_tune(&strm, input, sizeof(input) - 1);

    end_stream(&strm);
}

void test_deflateTune_negative_and_large_values_assignment_behavior(void) {
    z_stream strm;
    init_stream(&strm);

    int good = -1;      /* will be cast to uInt */
    int max_lazy = -2;  /* will be cast to uInt */
    int nice = -3;      /* assigned as int */
    int max_chain = -4; /* will be cast to uInt */

    int ret = deflateTune(&strm, good, max_lazy, nice, max_chain);
    TEST_ASSERT_EQUAL_INT(Z_OK, ret);

    deflate_state *s = (deflate_state *)strm.state;
    TEST_ASSERT_NOT_NULL(s);

    TEST_ASSERT_EQUAL_UINT((uInt)good, s->good_match);
    TEST_ASSERT_EQUAL_UINT((uInt)max_lazy, s->max_lazy_match);
    TEST_ASSERT_EQUAL_INT(nice, s->nice_match);
    TEST_ASSERT_EQUAL_UINT((uInt)max_chain, s->max_chain_length);

    /* Also test with large positive values */
    good = 70000; max_lazy = 65535; nice = 300000000; max_chain = 1234567890;
    ret = deflateTune(&strm, good, max_lazy, nice, max_chain);
    TEST_ASSERT_EQUAL_INT(Z_OK, ret);
    TEST_ASSERT_EQUAL_UINT((uInt)good, s->good_match);
    TEST_ASSERT_EQUAL_UINT((uInt)max_lazy, s->max_lazy_match);
    TEST_ASSERT_EQUAL_INT(nice, s->nice_match);
    TEST_ASSERT_EQUAL_UINT((uInt)max_chain, s->max_chain_length);

    end_stream(&strm);
}

void test_deflateTune_after_deflateEnd_returns_stream_error(void) {
    z_stream strm;
    init_stream(&strm);

    end_stream(&strm);

    int ret = deflateTune(&strm, 1, 2, 3, 4);
    TEST_ASSERT_EQUAL_INT(Z_STREAM_ERROR, ret);
}

int main(void) {
    UNITY_BEGIN();
    RUN_TEST(test_deflateTune_null_stream_returns_stream_error);
    RUN_TEST(test_deflateTune_uninitialized_stream_returns_stream_error);
    RUN_TEST(test_deflateTune_updates_internal_fields_basic);
    RUN_TEST(test_deflateTune_allows_zero_values_and_stream_works);
    RUN_TEST(test_deflateTune_negative_and_large_values_assignment_behavior);
    RUN_TEST(test_deflateTune_after_deflateEnd_returns_stream_error);
    return UNITY_END();
}