3 files changed, 779 insertions, 0 deletions
diff --git a/libs/cargs/test/definitions.h b/libs/cargs/test/definitions.h
new file mode 100755
index 0000000..cdb820e
--- /dev/null
+++ b/libs/cargs/test/definitions.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "tests.h"
+/**
+ * Creates prototypes for all test functions.
+ */
+#define XX(u, t) int u##_##t(void);
+UNIT_TESTS(XX)
+#undef XX
diff --git a/libs/cargs/test/main.c b/libs/cargs/test/main.c
new file mode 100755
index 0000000..229cf80
--- /dev/null
+++ b/libs/cargs/test/main.c
@@ -0,0 +1,105 @@
+#include "definitions.h"
+#include <cargs.h>
+#include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct cag_test
+{
+  const char *unit_name;
+  const char *test_name;
+  const char *full_name;
+  int (*fn)(void);
+};
+
+static struct cag_test tests[] = {
+#define XX(u, t)                                                               \
+  {.unit_name = #u, .test_name = #t, .full_name = #u "/" #t, .fn = u##_##t},
+  UNIT_TESTS(XX)
+#undef XX
+};
+
+static int call_test(struct cag_test *test)
+{
+  size_t i;
+
+  printf(" Running '%s' ", test->full_name);
+  for (i = strlen(test->full_name); i < 40; ++i) {
+    fputs(".", stdout);
+  }
+
+  if (test->fn() == EXIT_FAILURE) {
+    fputs(" FAILURE\n", stdout);
+    return EXIT_FAILURE;
+  }
+
+  fputs(" SUCCESS\n", stdout);
+  return EXIT_SUCCESS;
+}
+
+int main(int argc, char *argv[])
+{
+  size_t i, count, failed, succeeded;
+  const char *requested_unit_name, *requested_test_name;
+  struct cag_test *test;
+  double rate;
+
+  count = 0;
+  failed = 0;
+  if (argc < 2) {
+    fputs("No unit specified. Running all tests.\n\n", stdout);
+    for (i = 0; i < CAG_ARRAY_SIZE(tests); ++i) {
+      test = &tests[i];
+      ++count;
+      if (call_test(test) == EXIT_FAILURE) {
+        ++failed;
+      }
+    }
+  } else if (argc < 3) {
+    requested_unit_name = argv[1];
+    printf("Running all unit tests of '%s'.\n\n", requested_unit_name);
+    for (i = 0; i < CAG_ARRAY_SIZE(tests); ++i) {
+      test = &tests[i];
+      if (strcmp(test->unit_name, requested_unit_name) == 0) {
+        ++count;
+        if (call_test(test) == EXIT_FAILURE) {
+          ++failed;
+        }
+      }
+    }
+  } else {
+    requested_unit_name = argv[1];
+    requested_test_name = argv[2];
+    printf("Running a single test '%s/%s'.\n\n", requested_unit_name,
+      requested_test_name);
+    for (i = 0; i < CAG_ARRAY_SIZE(tests); ++i) {
+      test = &tests[i];
+      if (strcmp(test->unit_name, requested_unit_name) == 0 &&
+          strcmp(test->test_name, requested_test_name) == 0) {
+        ++count;
+        if (call_test(test) == EXIT_FAILURE) {
+          ++failed;
+        }
+      }
+    }
+  }
+
+  if (count == 1) {
+    fputs("\nThe test has been executed.\n", stdout);
+  } else if (count > 0) {
+    succeeded = count - failed;
+    rate = (double)succeeded / (double)count * 100;
+    printf("\n%zu/%zu (%.2f%%) of those tests succeeded.\n", succeeded, count,
+      rate);
+  } else {
+    printf("\nNo tests found.\n");
+    return EXIT_FAILURE;
+  }
+
+  if (failed > 0) {
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}
diff --git a/libs/cargs/test/option_test.c b/libs/cargs/test/option_test.c
new file mode 100755
index 0000000..c2dfff4
--- /dev/null
+++ b/libs/cargs/test/option_test.c
@@ -0,0 +1,665 @@
+#include "definitions.h"
+#include <assert.h>
+#include <cargs.h>
+#include <limits.h>
+#include <memory.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static struct cag_option options[] = {
+
+  {.identifier = 's',
+    .access_letters = "s",
+    .access_name = NULL,
+    .value_name = NULL,
+    .description = "Simple flag"},
+
+  {.identifier = 'a',
+    .access_letters = "a",
+    .access_name = NULL,
+    .value_name = NULL,
+    .description = "Another simple flag"},
+
+  {.identifier = 'm',
+    .access_letters = "mMoO",
+    .access_name = NULL,
+    .value_name = NULL,
+    .description = "Multiple access letters"},
+
+  {.identifier = 'l',
+    .access_letters = NULL,
+    .access_name = "long",
+    .value_name = NULL,
+    .description = "Long parameter name"},
+
+  {.identifier = 'k',
+    .access_letters = "k",
+    .access_name = "key",
+    .value_name = "VALUE",
+    .description = "Parameter value"}};
+
+struct cag_result
+{
+  bool simple;
+  bool another;
+  bool multi_access;
+  bool long_parameter;
+  bool value_parameter;
+  bool unknown;
+  bool def;
+  const char *value;
+};
+
+static struct cag_result result;
+static char **argv;
+static int argc;
+
+static int make_args(const char *str)
+{
+  const char *c;
+  int argIndex, argStart, argLength;
+
+  argc = 0;
+  c = str;
+  do {
+    if (*c == ' ' || *c == '\0') {
+      ++argc;
+    }
+  } while (*(c++));
+
+  argv = malloc(sizeof(char *) * (argc + 1));
+  if (argv == NULL) {
+    return 1;
+  }
+
+  c = str;
+  argIndex = 0;
+  argStart = 0;
+  argLength = 0;
+  do {
+    if (*c == ' ' || *c == '\0') {
+      argv[argIndex] = malloc(argLength + 1);
+      memcpy(argv[argIndex], &str[argStart], argLength);
+      argv[argIndex][argLength] = '\0';
+      ++argIndex;
+      argStart += argLength + 1;
+      argLength = 0;
+    } else {
+      ++argLength;
+    }
+
+  } while (*(c++));
+
+  argv[argc] = NULL;
+
+  return 0;
+}
+
+static void destroy_args()
+{
+  int i;
+
+  for (i = 0; i < argc; ++i) {
+    free(argv[i]);
+  }
+
+  free(argv);
+}
+
+static int option_test_run(int currentArgc, char *currentArgv[])
+{
+  int index;
+  char identifier;
+  cag_option_context context;
+
+  cag_option_prepare(&context, options, CAG_ARRAY_SIZE(options), currentArgc,
+    currentArgv);
+
+  memset(&result, 0, sizeof(result));
+
+  while (cag_option_fetch(&context)) {
+    identifier = cag_option_get(&context);
+    switch (identifier) {
+    case 's':
+      result.simple = true;
+      break;
+    case 'a':
+      result.another = true;
+      break;
+    case 'm':
+      result.multi_access = true;
+      break;
+    case 'l':
+      result.long_parameter = true;
+      break;
+    case 'k':
+      result.value_parameter = true;
+      result.value = cag_option_get_value(&context);
+      break;
+    case '?':
+      result.unknown = true;
+      break;
+    default:
+      result.def = true;
+      break;
+    }
+  }
+
+  index = cag_option_get_index(&context);
+  if (cag_option_fetch(&context) != false) {
+    return -1;
+  }
+
+  if (cag_option_get_index(&context) != index) {
+    return -1;
+  }
+
+  return cag_option_get_index(&context);
+}
+
+int option_complex(void)
+{
+  int status;
+
+  status = make_args("test file1 -s -- -a -- a file");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (!result.simple || result.another || result.multi_access ||
+      result.long_parameter || result.value_parameter || result.unknown ||
+      result.def || result.value != NULL) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_mixed(void)
+{
+  int status, i;
+
+  const char *values[] = {"file1", "file2", "mixed", "file3", "--", "-m",
+    "parameters", "file4"};
+
+  status = make_args(
+    "test -s file1 -k=value file2 -a mixed file3 -- -m parameters file4");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0 || argc - status != 8) {
+    goto err_wrong;
+  }
+
+  for (i = 0; i < (int)CAG_ARRAY_SIZE(values); ++i) {
+    if (strcmp(argv[status + i], values[i]) != 0) {
+      goto err_wrong;
+    }
+  }
+
+  if (!result.simple || !result.another || result.multi_access ||
+      result.long_parameter || !result.value_parameter || result.unknown ||
+      result.def || result.value == NULL ||
+      strcmp(result.value, "value") != 0) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_ending(void)
+{
+  int status;
+
+  status = make_args("test -s -- -a");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (!result.simple || result.another || result.multi_access ||
+      result.long_parameter || result.value_parameter || result.unknown ||
+      result.def || result.value != NULL) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_long_missing_value(void)
+{
+  int status;
+
+  status = make_args("test --key");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (result.simple || result.another || result.multi_access ||
+      result.long_parameter || !result.value_parameter || result.unknown ||
+      result.def || result.value != NULL) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_short_missing_value(void)
+{
+  int status;
+
+  status = make_args("test -k");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (result.simple || result.another || result.multi_access ||
+      result.long_parameter || !result.value_parameter || result.unknown ||
+      result.def || result.value != NULL) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_long_space_value(void)
+{
+  int status;
+
+  status = make_args("test --key super_value");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (result.simple || result.another || result.multi_access ||
+      result.long_parameter || !result.value_parameter || result.unknown ||
+      result.def || result.value == NULL ||
+      strcmp(result.value, "super_value") != 0) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_short_space_value(void)
+{
+  int status;
+
+  status = make_args("test -k test_value");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (result.simple || result.another || result.multi_access ||
+      result.long_parameter || !result.value_parameter || result.unknown ||
+      result.def || result.value == NULL ||
+      strcmp(result.value, "test_value") != 0) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_long_equal_value(void)
+{
+  int status;
+
+  status = make_args("test --key=super_value");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (result.simple || result.another || result.multi_access ||
+      result.long_parameter || !result.value_parameter || result.unknown ||
+      result.def || result.value == NULL ||
+      strcmp(result.value, "super_value") != 0) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_short_equal_value(void)
+{
+  int status;
+
+  status = make_args("test -k=test_value");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (result.simple || result.another || result.multi_access ||
+      result.long_parameter || !result.value_parameter || result.unknown ||
+      result.def || result.value == NULL ||
+      strcmp(result.value, "test_value") != 0) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_combined(void)
+{
+  int status;
+
+  status = make_args("test -sma");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (!result.simple || !result.another || !result.multi_access ||
+      result.long_parameter || result.value_parameter || result.unknown ||
+      result.def || result.value != NULL) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_unknown_long(void)
+{
+  int status;
+
+  status = make_args("test --unknown");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (result.simple || result.another || result.multi_access ||
+      result.long_parameter || result.value_parameter || !result.unknown ||
+      result.def || result.value != NULL) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_unknown_short(void)
+{
+  int status;
+
+  status = make_args("test -u");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (result.simple || result.another || result.multi_access ||
+      result.long_parameter || result.value_parameter || !result.unknown ||
+      result.def || result.value != NULL) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_alias(void)
+{
+  int status;
+
+  status = make_args("test -O");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (result.simple || result.another || !result.multi_access ||
+      result.long_parameter || result.value_parameter || result.unknown ||
+      result.def || result.value != NULL) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_simple_long(void)
+{
+  int status;
+
+  status = make_args("test --long");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (result.simple || result.another || result.multi_access ||
+      !result.long_parameter || result.value_parameter || result.unknown ||
+      result.def || result.value != NULL) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_simple(void)
+{
+  int status;
+
+  status = make_args("test -s");
+  if (status != 0) {
+    goto err_setup;
+  }
+
+  status = option_test_run(argc, argv);
+  if (status < 0) {
+    goto err_wrong;
+  }
+
+  if (!result.simple || result.another || result.multi_access ||
+      result.long_parameter || result.value_parameter || result.unknown ||
+      result.def || result.value != NULL) {
+    goto err_wrong;
+  }
+
+  destroy_args();
+
+  return EXIT_SUCCESS;
+
+err_wrong:
+  destroy_args();
+err_setup:
+  return EXIT_FAILURE;
+}
+
+int option_print(void)
+{
+  char buf[255];
+  const char *expected;
+  FILE *test_file;
+
+  expected = "  -s                   Simple flag\n"
+             "  -a                   Another simple flag\n"
+             "  -m, -M, -o, -O       Multiple access letters\n"
+             "  --long               Long parameter name\n"
+             "  -k, --key=VALUE      Parameter value\n";
+
+  test_file = tmpfile();
+  if (test_file == NULL) {
+    goto err_open;
+  }
+
+  cag_option_print(options, CAG_ARRAY_SIZE(options), test_file);
+  if (fseek(test_file, 0, SEEK_SET) != 0) {
+    goto err_seek;
+  }
+
+  if (fread(buf, sizeof(buf), 1, test_file) != 1 && feof(test_file) == 0) {
+    goto err_read;
+  }
+
+  if (memcmp(buf, expected, strlen(expected)) != 0) {
+    goto err_test;
+  }
+
+  fclose(test_file);
+  return EXIT_SUCCESS;
+
+err_test:
+err_read:
+err_seek:
+  fclose(test_file);
+err_open:
+  return EXIT_FAILURE;
+}