tests/tests_gzlib_gz_reset.c

#include "unity/unity.h"
#include "zlib.h"
#include "gzguts.h"

#include <stdlib.h>
#include <string.h>

/* Wrapper for the local function provided in gzlib.c */
extern void test_gz_reset(gz_statep state);

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

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

/* Helper to make a duplicated C string safely (returns NULL on failure) */
static char *dup_cstr(const char *s) {
    size_t len = strlen(s) + 1;
    char *p = (char *)malloc(len);
    if (p) memcpy(p, s, len);
    return p;
}

void test_gz_reset_write_mode_resets_general_fields(void) {
    gz_state state;
    memset(&state, 0, sizeof(state));

    /* Initialize fields with non-default values */
    state.mode = GZ_WRITE;
    state.x.have = 17;
    state.seek = 1;
    state.x.pos = 12345;
    state.strm.avail_in = 42;
    state.err = Z_STREAM_ERROR;          /* some non-OK error */
    state.msg = dup_cstr("old msg");     /* should be freed by gz_reset via gz_error */
    state.reset = 99;                    /* should be set to 0 by gz_reset in write mode */
    state.want = 777;                    /* should remain unchanged */
    state.level = 3;                     /* should remain unchanged */
    state.strategy = Z_RLE;              /* should remain unchanged */
    state.direct = 0;                    /* should remain unchanged */
    char *saved_path = dup_cstr("dummy/path");
    state.path = saved_path;             /* gz_reset should not touch path */

    test_gz_reset(&state);

    /* General resets */
    TEST_ASSERT_EQUAL(0u, state.x.have);
    TEST_ASSERT_EQUAL_INT(0, state.seek);
    TEST_ASSERT_EQUAL_UINT64(0, state.x.pos);
    TEST_ASSERT_EQUAL_UINT(0u, state.strm.avail_in);
    TEST_ASSERT_EQUAL_INT(Z_OK, state.err);
    TEST_ASSERT_NULL(state.msg);

    /* Write-mode specific reset */
    TEST_ASSERT_EQUAL_INT(0, state.reset);

    /* Unchanged fields */
    TEST_ASSERT_EQUAL_INT(GZ_WRITE, state.mode);
    TEST_ASSERT_EQUAL_UINT(777u, state.want);
    TEST_ASSERT_EQUAL_INT(3, state.level);
    TEST_ASSERT_EQUAL_INT(Z_RLE, state.strategy);
    TEST_ASSERT_EQUAL_INT(0, state.direct);
    TEST_ASSERT_TRUE(state.path == saved_path);

    /* Cleanup */
    free(saved_path);
}

void test_gz_reset_read_mode_resets_read_fields(void) {
    gz_state state;
    memset(&state, 0, sizeof(state));

    /* Initialize read-mode state */
    state.mode = GZ_READ;
    state.eof = 1;
    state.past = 1;
    state.how = COPY;          /* should become LOOK */
    state.direct = 1;          /* should remain unchanged */
    state.x.have = 5;
    state.seek = 1;
    state.x.pos = 999;
    state.strm.avail_in = 7;
    state.err = Z_BUF_ERROR;   /* acceptable non-fatal state */
    state.msg = NULL;
    state.want = 2048;         /* should remain unchanged */
    char *saved_path = dup_cstr("read/path");
    state.path = saved_path;

    test_gz_reset(&state);

    /* Read-mode specifics */
    TEST_ASSERT_EQUAL_INT(0, state.eof);
    TEST_ASSERT_EQUAL_INT(0, state.past);
    TEST_ASSERT_EQUAL_INT(LOOK, state.how);

    /* General resets */
    TEST_ASSERT_EQUAL(0u, state.x.have);
    TEST_ASSERT_EQUAL_INT(0, state.seek);
    TEST_ASSERT_EQUAL_UINT64(0, state.x.pos);
    TEST_ASSERT_EQUAL_UINT(0u, state.strm.avail_in);
    TEST_ASSERT_EQUAL_INT(Z_OK, state.err);
    TEST_ASSERT_NULL(state.msg);

    /* Unchanged fields */
    TEST_ASSERT_EQUAL_INT(GZ_READ, state.mode);
    TEST_ASSERT_EQUAL_INT(1, state.direct);
    TEST_ASSERT_EQUAL_UINT(2048u, state.want);
    TEST_ASSERT_TRUE(state.path == saved_path);

    /* Cleanup */
    free(saved_path);
}

void test_gz_reset_clears_mem_error_without_free(void) {
    gz_state state;
    memset(&state, 0, sizeof(state));

    state.mode = GZ_WRITE;
    state.err = Z_MEM_ERROR;
    /* Assign a string literal so that any erroneous free would be dangerous.
       gz_error should not free msg when prior err == Z_MEM_ERROR. */
    state.msg = (char *)"no-free";
    state.x.have = 3;
    state.seek = 1;
    state.x.pos = 55;
    state.strm.avail_in = 11;

    test_gz_reset(&state);

    /* Error cleared and message cleared */
    TEST_ASSERT_EQUAL_INT(Z_OK, state.err);
    TEST_ASSERT_NULL(state.msg);

    /* General resets */
    TEST_ASSERT_EQUAL(0u, state.x.have);
    TEST_ASSERT_EQUAL_INT(0, state.seek);
    TEST_ASSERT_EQUAL_UINT64(0, state.x.pos);
    TEST_ASSERT_EQUAL_UINT(0u, state.strm.avail_in);
}

int main(void) {
    UNITY_BEGIN();
    RUN_TEST(test_gz_reset_write_mode_resets_general_fields);
    RUN_TEST(test_gz_reset_read_mode_resets_read_fields);
    RUN_TEST(test_gz_reset_clears_mem_error_without_free);
    return UNITY_END();
}