tests/tests_pcre2_compile_class_append_char_list.c

/* tests_pcre2_compile_class_append_char_list.c
   Unity tests for append_char_list via the provided wrapper:
   size_t test_append_char_list(const uint32_t *p, uint32_t *buffer);
*/
#include "unity/unity.h"
#define PCRE2_CODE_UNIT_WIDTH 8
#include "pcre2.h"

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

/* Wrapper provided in the module under test */
extern size_t test_append_char_list(const uint32_t *p, uint32_t *buffer);

/* Local helper: sentinel used by the module (NOTACHAR == 0xffffffffu). */
static const uint32_t END = 0xffffffffu;

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

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

/* Empty list: should return 0 and not write anything when buffer is non-NULL */
void test_append_char_list_empty(void) {
  const uint32_t input[] = { END };
  uint32_t buffer[4];
  /* Fill with a sentinel value to check no writes occur */
  buffer[0] = 0xDEADBEEFu;
  buffer[1] = 0xDEADBEEFu;

  size_t r = test_append_char_list(input, buffer);
  TEST_ASSERT_EQUAL_UINT32(0u, (uint32_t)r);
  TEST_ASSERT_EQUAL_HEX32(0xDEADBEEFu, buffer[0]);
  TEST_ASSERT_EQUAL_HEX32(0xDEADBEEFu, buffer[1]);

  /* Also check size-only mode explicitly */
  r = test_append_char_list(input, NULL);
  TEST_ASSERT_EQUAL_UINT32(0u, (uint32_t)r);
}

/* Single element: [5] -> one range [5,5], returns 2 */
void test_append_char_list_single_element(void) {
  const uint32_t input[] = { 5u, END };

  size_t need = test_append_char_list(input, NULL);
  TEST_ASSERT_EQUAL_UINT32(2u, (uint32_t)need);

  uint32_t *out = (uint32_t*)malloc(sizeof(uint32_t) * need);
  TEST_ASSERT_NOT_NULL(out);

  size_t r = test_append_char_list(input, out);
  TEST_ASSERT_EQUAL_UINT32(2u, (uint32_t)r);
  TEST_ASSERT_EQUAL_UINT32(5u, out[0]);
  TEST_ASSERT_EQUAL_UINT32(5u, out[1]);

  free(out);
}

/* Contiguous run is coalesced: [1,2,3,4] -> [1,4] */
void test_append_char_list_contiguous_run(void) {
  const uint32_t input[] = { 1u, 2u, 3u, 4u, END };

  size_t need = test_append_char_list(input, NULL);
  TEST_ASSERT_EQUAL_UINT32(2u, (uint32_t)need);

  uint32_t out[2] = {0};
  size_t r = test_append_char_list(input, out);
  TEST_ASSERT_EQUAL_UINT32(2u, (uint32_t)r);
  TEST_ASSERT_EQUAL_UINT32(1u, out[0]);
  TEST_ASSERT_EQUAL_UINT32(4u, out[1]);
}

/* Multiple runs: [1,2,5,6,8] -> [1,2][5,6][8,8] */
void test_append_char_list_multiple_runs(void) {
  const uint32_t input[] = { 1u, 2u, 5u, 6u, 8u, END };

  size_t need = test_append_char_list(input, NULL);
  TEST_ASSERT_EQUAL_UINT32(6u, (uint32_t)need);

  uint32_t out[6] = {0};
  size_t r = test_append_char_list(input, out);
  TEST_ASSERT_EQUAL_UINT32(6u, (uint32_t)r);

  const uint32_t expected[] = { 1u, 2u, 5u, 6u, 8u, 8u };
  TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, out, 6);
}

/* Upper boundary near 0xffff: start must be < 0xffff; allow end == 0xffff
   Input: [0xfffe, 0xffff] -> [0xfffe, 0xffff] */
void test_append_char_list_upper_boundary(void) {
  const uint32_t input[] = { 0xfffeu, 0xffffu, END };

  size_t need = test_append_char_list(input, NULL);
  TEST_ASSERT_EQUAL_UINT32(2u, (uint32_t)need);

  uint32_t out[2] = {0};
  size_t r = test_append_char_list(input, out);
  TEST_ASSERT_EQUAL_UINT32(2u, (uint32_t)r);
  TEST_ASSERT_EQUAL_UINT32(0xfffeu, out[0]);
  TEST_ASSERT_EQUAL_UINT32(0xffffu, out[1]);
}

/* Non-consecutive singleton run at start and end */
void test_append_char_list_singletons_and_runs_mixed(void) {
  const uint32_t input[] = { 3u, 7u, 8u, 12u, END };
  /* Expect: [3,3], [7,8], [12,12] -> 6 values */
  size_t need = test_append_char_list(input, NULL);
  TEST_ASSERT_EQUAL_UINT32(6u, (uint32_t)need);

  uint32_t out[6] = {0};
  size_t r = test_append_char_list(input, out);
  TEST_ASSERT_EQUAL_UINT32(6u, (uint32_t)r);

  const uint32_t expected[] = { 3u, 3u, 7u, 8u, 12u, 12u };
  TEST_ASSERT_EQUAL_UINT32_ARRAY(expected, out, 6);
}

int main(void) {
  UNITY_BEGIN();

  RUN_TEST(test_append_char_list_empty);
  RUN_TEST(test_append_char_list_single_element);
  RUN_TEST(test_append_char_list_contiguous_run);
  RUN_TEST(test_append_char_list_multiple_runs);
  RUN_TEST(test_append_char_list_upper_boundary);
  RUN_TEST(test_append_char_list_singletons_and_runs_mixed);

  return UNITY_END();
}