tests/expr/tests_for_nextarg.c

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

/* setUp and tearDown required by Unity */
void setUp(void) {
  /* No global setup needed. Each test initializes args appropriately. */
}
void tearDown(void) {
  /* No global teardown needed. */
}

/* Tests for static bool nextarg (char const *str)
   Note: 'args' is a static global declared in the program source and is visible here. */

/* Helper to assert pointer equality for args */
static void assert_args_is(char **expected) {
  TEST_ASSERT_EQUAL_PTR(expected, args);
}

/* 1) No tokens: should return false and not advance */
void test_nextarg_no_tokens_returns_false_and_no_advance(void) {
  char *argv[] = { NULL };
  args = argv;

  char **before = args;
  bool r = nextarg("anything");

  TEST_ASSERT_FALSE(r);
  assert_args_is(before);
}

/* 2) Exact match advances once, then next call behaves from new position */
void test_nextarg_match_advances_pointer(void) {
  char *argv[] = { (char*)"foo", (char*)"bar", NULL };
  args = argv;

  bool r1 = nextarg("foo");
  TEST_ASSERT_TRUE(r1);
  assert_args_is(&argv[1]);

  bool r2 = nextarg("bar");
  TEST_ASSERT_TRUE(r2);
  assert_args_is(&argv[2]); /* Now pointing at NULL (end) */

  /* At end: should return false and remain at end */
  char **before = args;
  bool r3 = nextarg("baz");
  TEST_ASSERT_FALSE(r3);
  assert_args_is(before);
}

/* 3) Non-match does not advance */
void test_nextarg_nonmatch_does_not_advance(void) {
  char *argv[] = { (char*)"foo", (char*)"bar", NULL };
  args = argv;

  bool r = nextarg("qux");
  TEST_ASSERT_FALSE(r);
  assert_args_is(argv);
}

/* 4) Matching is exact, not prefix */
void test_nextarg_exact_match_only_not_prefix(void) {
  char *argv[] = { (char*)"foobar", NULL };
  args = argv;

  bool r1 = nextarg("foo");
  TEST_ASSERT_FALSE(r1);
  assert_args_is(argv);

  bool r2 = nextarg("foobar");
  TEST_ASSERT_TRUE(r2);
  assert_args_is(&argv[1]);
}

/* 5) Empty-string token and pattern handling */
void test_nextarg_empty_string_token_and_pattern(void) {
  char *argv[] = { (char*)"", (char*)"x", NULL };
  args = argv;

  bool r1 = nextarg("");
  TEST_ASSERT_TRUE(r1);
  assert_args_is(&argv[1]);

  bool r2 = nextarg("");
  TEST_ASSERT_FALSE(r2);
  assert_args_is(&argv[1]); /* Still at "x" */
}

/* 6) Interleaved matches and non-matches update pointer correctly */
void test_nextarg_interleaved_calls(void) {
  char *argv[] = { (char*)"a", (char*)"b", (char*)"c", NULL };
  args = argv;

  /* Non-match first: no advance */
  TEST_ASSERT_FALSE(nextarg("z"));
  assert_args_is(argv);

  /* Match 'a': advance to 'b' */
  TEST_ASSERT_TRUE(nextarg("a"));
  assert_args_is(&argv[1]);

  /* Non-match 'a' at 'b': no advance */
  TEST_ASSERT_FALSE(nextarg("a"));
  assert_args_is(&argv[1]);

  /* Match 'b': advance to 'c' */
  TEST_ASSERT_TRUE(nextarg("b"));
  assert_args_is(&argv[2]);

  /* Match 'c': advance to end */
  TEST_ASSERT_TRUE(nextarg("c"));
  assert_args_is(&argv[3]);

  /* End: further calls return false and keep pointer */
  char **endpos = args;
  TEST_ASSERT_FALSE(nextarg("anything"));
  assert_args_is(endpos);
}

/* Unity main */
int main(void) {
  UNITY_BEGIN();

  RUN_TEST(test_nextarg_no_tokens_returns_false_and_no_advance);
  RUN_TEST(test_nextarg_match_advances_pointer);
  RUN_TEST(test_nextarg_nonmatch_does_not_advance);
  RUN_TEST(test_nextarg_exact_match_only_not_prefix);
  RUN_TEST(test_nextarg_empty_string_token_and_pattern);
  RUN_TEST(test_nextarg_interleaved_calls);

  return UNITY_END();
}