tests/paste/tests_for_collapse_escapes.c

#include "../../unity/unity.h"
#include <stdlib.h>
#include <string.h>
#include <stddef.h>

/* collapse_escapes, delims, delim_end are available from the included program. */

static void verify_collapse(const char *input,
                            const unsigned char *expected,
                            size_t expected_len,
                            int expected_ret)
{
    int r = collapse_escapes(input);
    TEST_ASSERT_EQUAL_INT_MESSAGE(expected_ret, r, "Unexpected return value from collapse_escapes");

    TEST_ASSERT_NOT_NULL_MESSAGE(delims, "delims should not be NULL after collapse_escapes");
    TEST_ASSERT_TRUE_MESSAGE(delim_end >= delims, "delim_end should be >= delims");

    size_t actual_len = (size_t)(delim_end - delims);
    TEST_ASSERT_EQUAL_size_t_MESSAGE(expected_len, actual_len, "Unexpected length of delims");

    if (expected_len > 0)
    {
        TEST_ASSERT_EQUAL_INT_MESSAGE(0, memcmp(delims, expected, expected_len),
                                      "delims content does not match expected bytes");
    }

    /* Clean up allocation performed by collapse_escapes (via xstrdup). */
    free(delims);
    delims = NULL;
    delim_end = NULL;
}

void setUp(void) {
    /* No setup needed */
}

void tearDown(void) {
    /* No teardown needed */
}

void test_collapse_escapes_basic_plain_copy(void)
{
    const char *in = "abcDEF123";
    const unsigned char expected[] = {'a','b','c','D','E','F','1','2','3'};
    verify_collapse(in, expected, sizeof(expected), 0);
}

void test_collapse_escapes_standard_escapes(void)
{
    const char *in = "\\t\\n\\r\\b\\v\\f\\\\";
    const unsigned char expected[] = {'\t','\n','\r','\b','\v','\f','\\'};
    verify_collapse(in, expected, sizeof(expected), 0);
}

void test_collapse_escapes_unknown_escape_literal(void)
{
    const char *in = "A\\qy";
    const unsigned char expected[] = {'A','q','y'};
    verify_collapse(in, expected, sizeof(expected), 0);
}

void test_collapse_escapes_zero_sentinel_middle(void)
{
    const char *in = "a\\0b";
    const unsigned char expected[] = {'a','\0','b'};
    verify_collapse(in, expected, sizeof(expected), 0);
}

void test_collapse_escapes_trailing_backslash_ignored_and_reports(void)
{
    const char *in = "abc\\";
    const unsigned char expected[] = {'a','b','c'};
    verify_collapse(in, expected, sizeof(expected), 1);
}

void test_collapse_escapes_empty_input(void)
{
    const char *in = "";
    const unsigned char expected[] = { /* empty */ };
    verify_collapse(in, expected, 0, 0);
}

void test_collapse_escapes_double_zero_then_digit(void)
{
    const char *in = "\\00";
    const unsigned char expected[] = {'\0','0'};
    verify_collapse(in, expected, sizeof(expected), 0);
}

void test_collapse_escapes_mixed_sequence(void)
{
    const char *in = "x\\ty\\nz\\rb\\fc\\\\d";
    const unsigned char expected[] = {'x','\t','y','\n','z','\r','b','\f','c','\\','d'};
    verify_collapse(in, expected, sizeof(expected), 0);
}

void test_collapse_escapes_only_zero_delims(void)
{
    const char *in = "\\0\\0";
    const unsigned char expected[] = {'\0','\0'};
    verify_collapse(in, expected, sizeof(expected), 0);
}

void test_collapse_escapes_backslash_backslash(void)
{
    const char *in = "\\\\";
    const unsigned char expected[] = {'\\'};
    verify_collapse(in, expected, sizeof(expected), 0);
}

int main(void)
{
    UNITY_BEGIN();
    RUN_TEST(test_collapse_escapes_basic_plain_copy);
    RUN_TEST(test_collapse_escapes_standard_escapes);
    RUN_TEST(test_collapse_escapes_unknown_escape_literal);
    RUN_TEST(test_collapse_escapes_zero_sentinel_middle);
    RUN_TEST(test_collapse_escapes_trailing_backslash_ignored_and_reports);
    RUN_TEST(test_collapse_escapes_empty_input);
    RUN_TEST(test_collapse_escapes_double_zero_then_digit);
    RUN_TEST(test_collapse_escapes_mixed_sequence);
    RUN_TEST(test_collapse_escapes_only_zero_delims);
    RUN_TEST(test_collapse_escapes_backslash_backslash);
    return UNITY_END();
}