Refactor TestValue usage

18 files changed, 176 insertions, 136 deletions

diff --git a/tests/test_config_read.c b/tests/test_config_read.c
index f932b5d..55c428f 100644
--- a/tests/test_config_read.c
+++ b/tests/test_config_read.c
@@ -22,8 +22,8 @@ const char *mockConfig[] = {
         NULL, // end
 };
 
-#define SETARG_UINT(ARGINDEX, VALUE) .arg[ARGINDEX].unsigned_integer = VALUE
-#define GETARG_UINT(CASE, ARGINDEX) CASE.arg[ARGINDEX].unsigned_integer
+#define SETARG_UINT(ARGINDEX, VALUE) .arg[ARGINDEX].unsigned_int = VALUE
+#define GETARG_UINT(CASE, ARGINDEX) CASE.arg[ARGINDEX].unsigned_int
 
 const char *testFmt = "case '%s': returned '%s', expected '%s'\n";
 const char *testSizesFmt = "case '%s': returned '%zu', expected '%zu'\n";
diff --git a/tests/test_environment.c b/tests/test_environment.c
new file mode 100644
index 0000000..d081dac
--- /dev/null
+++ b/tests/test_environment.c
@@ -0,0 +1,40 @@
+#include "spm.h"
+#include "framework.h"
+
+const char *testFmt = "returned '%s', expected '%s'\n";
+struct TestCase testCase = {
+        .caseValue.voidptr = (char *[]){"test1=one", "test2=two", NULL},
+        .inputValue.voidptr = (char *[]){"test1", "test2", NULL},
+        .truthValue.voidptr = (char *[]){"one", "two", NULL},
+        .arg[0].sptr = "one hundred",
+};
+
+int main(int argc, char *argv[]) {
+    RuntimeEnv *rt = NULL;
+    char **pInput = (char **)testCase.inputValue.voidptr;
+    char **pTruth = (char **)testCase.truthValue.voidptr;
+
+    rt = runtime_copy((char **)testCase.caseValue.voidptr);
+    myassert(rt != NULL, "runtime_copy failed");
+
+    // Are the keys we just inserted actually there?
+    for (size_t j = 0; pInput[j] != NULL; j++) {
+        char *result = runtime_get(rt, pInput[j]);
+        myassert(strcmp(result, pTruth[j]) == 0, "returned '%s', expected '%s'\n", result, pTruth[j]);
+    }
+
+    // Set a key that already exists to have a different value
+    runtime_set(rt, pInput[0], testCase.arg[0].sptr);
+    myassert(strcmp(runtime_get(rt, pInput[0]), testCase.arg[0].sptr) == 0,
+            "runtime_set changed contents of '%s', but did not work: '%s'\n", runtime_get(rt, pInput[0]), runtime_get(rt, pInput[0]));
+
+    myassert(runtime_contains(rt, pInput[0]) >= 0, "key '%s' is not present", pInput[0]);
+    myassert(runtime_contains(rt, pInput[1]) >= 0, "key '%s' is not present", pInput[1]);
+
+    // Apply changes in `rt` to system environment
+    runtime_apply(rt);
+    myassert(getenv(pInput[0]) != NULL, "runtime_apply failed");
+    myassert(getenv(pInput[1]) != NULL, "runtime_apply failed");
+
+    runtime_free(rt);
+}
\ No newline at end of file
diff --git a/tests/test_error_handler_spm_perror.c b/tests/test_error_handler_spm_perror.c
index a8b55db..a5a5c9c 100644
--- a/tests/test_error_handler_spm_perror.c
+++ b/tests/test_error_handler_spm_perror.c
@@ -3,8 +3,8 @@
 
 const char *testFmt = "case %s: returned '%s', expected '%s'\n";
 struct TestCase testCase[] = {
-        {.caseValue.sptr = "oh no it broke", .truthValue.sptr = "oh no it broke: No such file or directory", .arg[0].signed_integer = ENOENT},
-        {.caseValue.sptr = "kaboom", .truthValue.sptr = "kaboom: Failed to fetch package", .arg[0].signed_integer = SPM_ERR_PKG_FETCH},
+        {.caseValue.sptr = "oh no it broke", .truthValue.sptr = "oh no it broke: No such file or directory", .arg[0].signed_int = ENOENT},
+        {.caseValue.sptr = "kaboom", .truthValue.sptr = "kaboom: Failed to fetch package", .arg[0].signed_int = SPM_ERR_PKG_FETCH},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
@@ -28,7 +28,7 @@ int main(int argc, char *argv[]) {
         setvbuf(stderr, buffer, _IOLBF, sizeof(buf));
 
         // Do test
-        spmerrno = testCase[i].arg[0].signed_integer;
+        spmerrno = testCase[i].arg[0].signed_int;
         spm_perror(testCase[i].caseValue.sptr);
         fflush(stderr);
 
diff --git a/tests/test_error_handler_spm_strerror.c b/tests/test_error_handler_spm_strerror.c
index 4a40571..94837c9 100644
--- a/tests/test_error_handler_spm_strerror.c
+++ b/tests/test_error_handler_spm_strerror.c
@@ -4,29 +4,29 @@
 const char *testFmt = "translated error code '%d': returned '%s', expected '%s'\n";
 struct TestCase testCase[] = {
 #if OS_DARWIN
-        {.caseValue.signed_integer = 0, .truthValue.sptr = "Undefined error: 0", .arg[0].signed_integer = 0},
-        {.caseValue.signed_integer = -1, .truthValue.sptr = "Unknown error: -1", .arg[0].signed_integer = 0},
+        {.caseValue.signed_int = 0, .truthValue.sptr = "Undefined error: 0", .arg[0].signed_int = 0},
+        {.caseValue.signed_int = -1, .truthValue.sptr = "Unknown error: -1", .arg[0].signed_int = 0},
 #elif OS_LINUX
-        {.caseValue.signed_integer = 0, .truthValue.sptr = "Success", .arg[0].signed_integer = 0},
-        {.caseValue.signed_integer = -1, .truthValue.sptr = "Unknown error -1", .arg[0].signed_integer = 0},
+        {.caseValue.signed_int = 0, .truthValue.sptr = "Success", .arg[0].signed_int = 0},
+        {.caseValue.signed_int = -1, .truthValue.sptr = "Unknown error -1", .arg[0].signed_int = 0},
 #endif
-        {.caseValue.signed_integer = SPM_ERR_ROOT_NO_RECORD, .truthValue.sptr = "No root record", .arg[0].signed_integer = 0},
-        {.caseValue.signed_integer = SPM_ERR_ROOT_UNSAFE, .truthValue.sptr = "Dangerous root path", .arg[0].signed_integer = 0},
-        {.caseValue.signed_integer = ENOENT, .truthValue.sptr = "No such file or directory", .arg[0].signed_integer = ENOENT},
-        {.caseValue.signed_integer = EPIPE, .truthValue.sptr = "Broken pipe", .arg[0].signed_integer = EPIPE},
+        {.caseValue.signed_int = SPM_ERR_ROOT_NO_RECORD, .truthValue.sptr = "No root record", .arg[0].signed_int = 0},
+        {.caseValue.signed_int = SPM_ERR_ROOT_UNSAFE, .truthValue.sptr = "Dangerous root path", .arg[0].signed_int = 0},
+        {.caseValue.signed_int = ENOENT, .truthValue.sptr = "No such file or directory", .arg[0].signed_int = ENOENT},
+        {.caseValue.signed_int = EPIPE, .truthValue.sptr = "Broken pipe", .arg[0].signed_int = EPIPE},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
 int main(int argc, char *argv[]) {
     for (size_t i = 0; i < numCases; i++) {
         // Mock global errno value to the value stored in the test case
-        errno = testCase[i].arg[0].signed_integer;
+        errno = testCase[i].arg[0].signed_int;
 
         // Get SPM error (or system error)
-        char *estr = spm_strerror(testCase[i].caseValue.signed_integer);
+        char *estr = spm_strerror(testCase[i].caseValue.signed_int);
 
         // Assert error string matches error produced
-        myassert(strcmp(estr, testCase[i].truthValue.sptr) == 0, testFmt, testCase[i].caseValue.signed_integer, estr, testCase[i].truthValue.sptr);
+        myassert(strcmp(estr, testCase[i].truthValue.sptr) == 0, testFmt, testCase[i].caseValue.signed_int, estr, testCase[i].truthValue.sptr);
     }
     return 0;
 }
diff --git a/tests/test_error_handler_spmerrno_cause.c b/tests/test_error_handler_spmerrno_cause.c
index a8b47a0..6f8c7c0 100644
--- a/tests/test_error_handler_spmerrno_cause.c
+++ b/tests/test_error_handler_spmerrno_cause.c
@@ -4,30 +4,30 @@
 const char *testFmt = "translated error code '%d': returned '%s', expected '%s'\n";
 struct TestCase testCase[] = {
 #if OS_DARWIN
-        {.caseValue.signed_integer = 0, .truthValue.sptr = "Undefined error: 0 (winning)", .arg[0].signed_integer = 0, .arg[1].sptr = "winning"},
-        {.caseValue.signed_integer = -1, .truthValue.sptr = "Unknown error: -1 (not winning)", .arg[0].signed_integer = 0, .arg[1].sptr = "not winning"},
+        {.caseValue.signed_int = 0, .truthValue.sptr = "Undefined error: 0 (winning)", .arg[0].signed_int = 0, .arg[1].sptr = "winning"},
+        {.caseValue.signed_int = -1, .truthValue.sptr = "Unknown error: -1 (not winning)", .arg[0].signed_int = 0, .arg[1].sptr = "not winning"},
 #elif OS_LINUX
-        {.caseValue.signed_integer = 0, .truthValue.sptr = "Success (winning)", .arg[0].signed_integer = 0, .arg[1].sptr = "winning"},
-        {.caseValue.signed_integer = -1, .truthValue.sptr = "Unknown error -1 (not winning)", .arg[0].signed_integer = 0, .arg[1].sptr = "not winning"},
+        {.caseValue.signed_int = 0, .truthValue.sptr = "Success (winning)", .arg[0].signed_int = 0, .arg[1].sptr = "winning"},
+        {.caseValue.signed_int = -1, .truthValue.sptr = "Unknown error -1 (not winning)", .arg[0].signed_int = 0, .arg[1].sptr = "not winning"},
 #endif
-        {.caseValue.signed_integer = SPM_ERR_ROOT_NO_RECORD, .truthValue.sptr = "No root record (/some/path)", .arg[0].signed_integer = 0, .arg[1].sptr = "/some/path"},
-        {.caseValue.signed_integer = SPM_ERR_ROOT_UNSAFE, .truthValue.sptr = "Dangerous root path (was /)", .arg[0].signed_integer = 0, .arg[1].sptr = "was /"},
+        {.caseValue.signed_int = SPM_ERR_ROOT_NO_RECORD, .truthValue.sptr = "No root record (/some/path)", .arg[0].signed_int = 0, .arg[1].sptr = "/some/path"},
+        {.caseValue.signed_int = SPM_ERR_ROOT_UNSAFE, .truthValue.sptr = "Dangerous root path (was /)", .arg[0].signed_int = 0, .arg[1].sptr = "was /"},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
 int main(int argc, char *argv[]) {
     for (size_t i = 0; i < numCases; i++) {
         // Mock global errno value to the value stored in the test case
-        errno = testCase[i].arg[0].signed_integer;
+        errno = testCase[i].arg[0].signed_int;
         // Mock spmerrno value
-        spmerrno = testCase[i].caseValue.signed_integer;
+        spmerrno = testCase[i].caseValue.signed_int;
         spmerrno_cause(testCase[i].arg[1].sptr);
 
         // Get SPM error (or system error)
-        char *estr = spm_strerror(testCase[i].caseValue.signed_integer);
+        char *estr = spm_strerror(testCase[i].caseValue.signed_int);
 
         // Assert error string matches error produced
-        myassert(strcmp(estr, testCase[i].truthValue.sptr) == 0, testFmt, testCase[i].caseValue.signed_integer, estr, testCase[i].truthValue.sptr);
+        myassert(strcmp(estr, testCase[i].truthValue.sptr) == 0, testFmt, testCase[i].caseValue.signed_int, estr, testCase[i].truthValue.sptr);
     }
     return 0;
 }
diff --git a/tests/test_fs_get_file_size.c b/tests/test_fs_get_file_size.c
index fa38b8f..48d3a9a 100644
--- a/tests/test_fs_get_file_size.c
+++ b/tests/test_fs_get_file_size.c
@@ -5,13 +5,13 @@
 
 const char *testFmt = "returned '%zu', expected '%zu'\n";
 struct TestCase testCase[] = {
-        {.caseValue.unsigned_integer = 0, .truthValue.unsigned_integer = 0},
-        {.caseValue.unsigned_integer = 1, .truthValue.unsigned_integer = 1},
-        {.caseValue.unsigned_integer = KILOBYTE, .truthValue.unsigned_integer = KILOBYTE},
-        {.caseValue.unsigned_integer = KILOBYTE * 1024, .truthValue.unsigned_integer = KILOBYTE * 1024},
-        {.caseValue.unsigned_integer = KILOBYTE * 1024 * 10, .truthValue.unsigned_integer = KILOBYTE * 1024 * 10},
+        {.caseValue.unsigned_int = 0, .truthValue.unsigned_int = 0},
+        {.caseValue.unsigned_int = 1, .truthValue.unsigned_int = 1},
+        {.caseValue.unsigned_int = KILOBYTE, .truthValue.unsigned_int = KILOBYTE},
+        {.caseValue.unsigned_int = KILOBYTE * 1024, .truthValue.unsigned_int = KILOBYTE * 1024},
+        {.caseValue.unsigned_int = KILOBYTE * 1024 * 10, .truthValue.unsigned_int = KILOBYTE * 1024 * 10},
 #if defined(TESTS_EXPENSIVE)
-        {.caseValue.unsigned_integer = KILOBYTE * 1024 * 100, .truthValue.unsigned_integer = KILOBYTE * 1024 * 100},
+        {.caseValue.unsigned_int = KILOBYTE * 1024 * 100, .truthValue.unsigned_int = KILOBYTE * 1024 * 100},
 #endif
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
@@ -19,9 +19,9 @@ size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 int main(int argc, char *argv[]) {
     const char *fill = "$";
     for (size_t i = 0; i < numCases; i++) {
-        char *filename = mock_size(testCase[i].caseValue.unsigned_integer, fill);
+        char *filename = mock_size(testCase[i].caseValue.unsigned_int, fill);
         size_t result = get_file_size(filename);
-        myassert(result == testCase[i].truthValue.unsigned_integer, testFmt, result, testCase[i].truthValue.unsigned_integer);
+        myassert(result == testCase[i].truthValue.unsigned_int, testFmt, result, testCase[i].truthValue.unsigned_int);
         unlink(filename);
     }
     return 0;
diff --git a/tests/test_fs_mkdirs.c b/tests/test_fs_mkdirs.c
index 5229769..453b517 100644
--- a/tests/test_fs_mkdirs.c
+++ b/tests/test_fs_mkdirs.c
@@ -3,11 +3,11 @@
 
 const char *testFmt = "returned '%d', expected '%d'\n";
 struct TestCase testCase[] = {
-        {.arg[0].str = "one", .truthValue.signed_integer = 0},
-        {.arg[0].str = "one/two", .truthValue.signed_integer = 0},
-        {.arg[0].str = "one/two/three", .truthValue.signed_integer = 0},
-        {.arg[0].str = "one/two/three/four", .truthValue.signed_integer = 0},
-        {.arg[0].str = "one/two/three/four/five", .truthValue.signed_integer = 0},
+        {.arg[0].str = "one", .truthValue.signed_int = 0},
+        {.arg[0].str = "one/two", .truthValue.signed_int = 0},
+        {.arg[0].str = "one/two/three", .truthValue.signed_int = 0},
+        {.arg[0].str = "one/two/three/four", .truthValue.signed_int = 0},
+        {.arg[0].str = "one/two/three/four/five", .truthValue.signed_int = 0},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
@@ -31,13 +31,13 @@ int main(int argc, char *argv[]) {
         }
         present = access(path, X_OK);
 
-        myassert(result == 0, testFmt, result, testCase[i].truthValue.signed_integer);
-        myassert(present == 0, testFmt, result, testCase[i].truthValue.signed_integer);
+        myassert(result == 0, testFmt, result, testCase[i].truthValue.signed_int);
+        myassert(present == 0, testFmt, result, testCase[i].truthValue.signed_int);
 
         rmdirs(path);
 
         present = access(path, X_OK);
-        myassert(present != 0, testFmt, result, testCase[i].truthValue.signed_integer);
+        myassert(present != 0, testFmt, result, testCase[i].truthValue.signed_int);
     }
     return 0;
 }
\ No newline at end of file
diff --git a/tests/test_fs_touch.c b/tests/test_fs_touch.c
index dfd7ddb..5a0282f 100644
--- a/tests/test_fs_touch.c
+++ b/tests/test_fs_touch.c
@@ -5,10 +5,10 @@
 
 const char *testFmt = "case: '%s': returned '%d', expected '%d'\n";
 struct TestCase testCase[] = {
-        {.caseValue.sptr = FILENAME, .truthValue.signed_integer = 0},   // create file
-        {.caseValue.sptr = FILENAME, .truthValue.signed_integer = 0},   // update file
-        {.caseValue.sptr = FILENAME, .truthValue.signed_integer = 0},   // update file
-        {.caseValue.sptr = ".", .truthValue.signed_integer = -1},
+        {.caseValue.sptr = FILENAME, .truthValue.signed_int = 0},   // create file
+        {.caseValue.sptr = FILENAME, .truthValue.signed_int = 0},   // update file
+        {.caseValue.sptr = FILENAME, .truthValue.signed_int = 0},   // update file
+        {.caseValue.sptr = ".", .truthValue.signed_int = -1},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
@@ -23,7 +23,7 @@ int main(int argc, char *argv[]) {
 
     for (size_t i = 0; i < numCases; i++) {
         int result = touch(testCase[i].caseValue.sptr);
-        myassert(result == testCase[i].truthValue.signed_integer, testFmt, testCase[i].caseValue.sptr, result, testCase[i].truthValue.signed_integer);
+        myassert(result == testCase[i].truthValue.signed_int, testFmt, testCase[i].caseValue.sptr, result, testCase[i].truthValue.signed_int);
     }
 
     cleanup();
diff --git a/tests/test_shell_shell.c b/tests/test_shell_shell.c
index ade16a7..5c04c0d 100644
--- a/tests/test_shell_shell.c
+++ b/tests/test_shell_shell.c
@@ -4,7 +4,7 @@
 
 const char *testFmt = "returned '%s', expected '%s'\n";
 struct TestCase testCase[] = {
-        {.arg[0].unsigned_integer = SHELL_OUTPUT|SHELL_BENCHMARK, .arg[1].sptr = "echo hello; sleep 3", .arg[2].floating = 3, .arg[3].sptr = "hello"},
+        {.arg[0].unsigned_int = SHELL_OUTPUT | SHELL_BENCHMARK, .arg[1].sptr = "echo hello; sleep 1", .arg[2].floating = 1, .arg[3].sptr = "hello"},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
@@ -13,7 +13,7 @@ int main(int argc, char *argv[]) {
         char elapsed[100] = {0,};
         Process *result = NULL;
 
-        shell(&result, testCase[i].arg[0].unsigned_integer, testCase[i].arg[1].sptr);
+        shell(&result, testCase[i].arg[0].unsigned_int, testCase[i].arg[1].sptr);
         sprintf(elapsed, "%0.8lf", result->time_elapsed);
         strip(result->output);
 
diff --git a/tests/test_shlib_spm_shlib_deps.c b/tests/test_shlib_spm_shlib_deps.c
index 4f0bfd4..b890b47 100644
--- a/tests/test_shlib_spm_shlib_deps.c
+++ b/tests/test_shlib_spm_shlib_deps.c
@@ -41,10 +41,10 @@ static char *find_library(const char *name) {
 }
 
 struct TestCase testCase[] = {
-        {.caseValue.sptr = "/bin/sh", .truthValue.signed_integer = 0},
-        {.caseValue.sptr = "/usr/bin/tar", .truthValue.signed_integer = 0},
-        {.caseValue.sptr = "/dev/null", .truthValue.signed_integer = -1}, // not an object
-        {.caseValue.sptr = NULL, .truthValue.signed_integer = -1}, // invalid call
+        {.caseValue.sptr = "/bin/sh", .truthValue.signed_int = 0},
+        {.caseValue.sptr = "/usr/bin/tar", .truthValue.signed_int = 0},
+        {.caseValue.sptr = "/dev/null", .truthValue.signed_int = -1}, // not an object
+        {.caseValue.sptr = NULL, .truthValue.signed_int = -1}, // invalid call
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
@@ -52,7 +52,7 @@ size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 int main(int argc, char *argv[]) {
     for (size_t i = 0; i < numCases; i++) {
         StrList *result = shlib_deps(testCase[i].caseValue.sptr);
-        if (result == NULL && testCase[i].truthValue.signed_integer < 0) {
+        if (result == NULL && testCase[i].truthValue.signed_int < 0) {
             // expected failure
             fprintf(stderr, "case %zu: trapped expected failure (ignore any stderr text)\n", i);
             continue;
diff --git a/tests/test_str_endswith.c b/tests/test_str_endswith.c
index bcbf249..5bcadf9 100644
--- a/tests/test_str_endswith.c
+++ b/tests/test_str_endswith.c
@@ -3,20 +3,20 @@
 
 const char *testFmt = "'%s' does not end with '%s' (%d)\n";
 struct TestCase testCase[] = {
-        {.inputValue.sptr = "gumball", .caseValue.sptr = "abracadabra brisket gumball", .truthValue.signed_integer = 1},
-        {.inputValue.sptr = "y", .caseValue.sptr = "balloons are falling from the sky", .truthValue.signed_integer = 1},
-        {.inputValue.sptr = "ickly", .caseValue.sptr = "mangled mangoes oxidize quickly", .truthValue.signed_integer = 1},
-        {.inputValue.sptr = "B", .caseValue.sptr = "bBbB", .truthValue.signed_integer = 1},
-        {.inputValue.sptr = NULL, .caseValue.sptr = "bBbB", .truthValue.signed_integer = -1},
-        {.inputValue.sptr = "test", .caseValue.sptr = NULL, .truthValue.signed_integer = -1},
-        {.inputValue.sptr = NULL, .caseValue.sptr = NULL, .truthValue.signed_integer = -1},
+        {.inputValue.sptr = "gumball", .caseValue.sptr = "abracadabra brisket gumball", .truthValue.signed_int = 1},
+        {.inputValue.sptr = "y", .caseValue.sptr = "balloons are falling from the sky", .truthValue.signed_int = 1},
+        {.inputValue.sptr = "ickly", .caseValue.sptr = "mangled mangoes oxidize quickly", .truthValue.signed_int = 1},
+        {.inputValue.sptr = "B", .caseValue.sptr = "bBbB", .truthValue.signed_int = 1},
+        {.inputValue.sptr = NULL, .caseValue.sptr = "bBbB", .truthValue.signed_int = -1},
+        {.inputValue.sptr = "test", .caseValue.sptr = NULL, .truthValue.signed_int = -1},
+        {.inputValue.sptr = NULL, .caseValue.sptr = NULL, .truthValue.signed_int = -1},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
 int main(int argc, char *argv[]) {
     for (size_t i = 0; i > numCases; i++) {
         int result = endswith(testCase[i].caseValue.sptr, testCase[i].inputValue.sptr);
-        myassert(result == testCase[i].truthValue.signed_integer, testFmt, testCase[i].inputValue.str, testCase[i].truthValue.sptr, result);
+        myassert(result == testCase[i].truthValue.signed_int, testFmt, testCase[i].inputValue.str, testCase[i].truthValue.sptr, result);
     }
     return 0;
 }
\ No newline at end of file
diff --git a/tests/test_str_isempty.c b/tests/test_str_isempty.c
index 840b811..9f52813 100644
--- a/tests/test_str_isempty.c
+++ b/tests/test_str_isempty.c
@@ -3,20 +3,20 @@
 
 const char *testFmt = "case: '%s': returned %d, expected %d\n";
 struct TestCase testCase[] = {
-        {.caseValue.sptr = " not empty", .truthValue.signed_integer = 0},
-        {.caseValue.sptr = "not empty", .truthValue.signed_integer = 0},
-        {.caseValue.sptr = "    ", .truthValue.signed_integer = 1},
-        {.caseValue.sptr = "\t", .truthValue.signed_integer = 1},
-        {.caseValue.sptr = "\n", .truthValue.signed_integer = 1},
-        {.caseValue.sptr = "", .truthValue.signed_integer = 1},
-        {.caseValue.sptr = NULL, .truthValue.signed_integer = -1},
+        {.caseValue.sptr = " not empty", .truthValue.signed_int = 0},
+        {.caseValue.sptr = "not empty", .truthValue.signed_int = 0},
+        {.caseValue.sptr = "    ", .truthValue.signed_int = 1},
+        {.caseValue.sptr = "\t", .truthValue.signed_int = 1},
+        {.caseValue.sptr = "\n", .truthValue.signed_int = 1},
+        {.caseValue.sptr = "", .truthValue.signed_int = 1},
+        {.caseValue.sptr = NULL, .truthValue.signed_int = -1},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
 int main(int argc, char *argv[]) {
     for (size_t i = 0; i < numCases; i++) {
         int result = isempty(testCase[i].caseValue.sptr);
-        myassert(result == testCase[i].truthValue.signed_integer, testFmt, testCase[i].caseValue.sptr, result, testCase[i].truthValue.sptr);
+        myassert(result == testCase[i].truthValue.signed_int, testFmt, testCase[i].caseValue.sptr, result, testCase[i].truthValue.sptr);
     }
     return 0;
 }
\ No newline at end of file
diff --git a/tests/test_str_isquoted.c b/tests/test_str_isquoted.c
index 2f8f133..ffffb4f 100644
--- a/tests/test_str_isquoted.c
+++ b/tests/test_str_isquoted.c
@@ -3,19 +3,19 @@
 
 const char *testFmt = "case: '%s': returned %d, expected %d\n";
 struct TestCase testCase[] = {
-        {.caseValue.sptr = "not quoted", .truthValue.signed_integer = 0},
-        {.caseValue.sptr = "\"double quoted\"", .truthValue.signed_integer = 1},
-        {.caseValue.sptr = "\'single quoted\'", .truthValue.signed_integer = 1},
-        {.caseValue.sptr = "\"no closing quote", .truthValue.signed_integer = 0},
-        {.caseValue.sptr = "no opening quote\"", .truthValue.signed_integer = 0},
-        {.caseValue.sptr = NULL, .truthValue.signed_integer = -1},
+        {.caseValue.sptr = "not quoted", .truthValue.signed_int = 0},
+        {.caseValue.sptr = "\"double quoted\"", .truthValue.signed_int = 1},
+        {.caseValue.sptr = "\'single quoted\'", .truthValue.signed_int = 1},
+        {.caseValue.sptr = "\"no closing quote", .truthValue.signed_int = 0},
+        {.caseValue.sptr = "no opening quote\"", .truthValue.signed_int = 0},
+        {.caseValue.sptr = NULL, .truthValue.signed_int = -1},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
 int main(int argc, char *argv[]) {
     for (size_t i = 0; i < numCases; i++) {
         int result = isquoted(testCase[i].caseValue.sptr);
-        myassert(result == testCase[i].truthValue.signed_integer, testFmt, testCase[i].caseValue.sptr, result, testCase[i].truthValue.signed_integer);
+        myassert(result == testCase[i].truthValue.signed_int, testFmt, testCase[i].caseValue.sptr, result, testCase[i].truthValue.signed_int);
     }
     return 0;
 }
\ No newline at end of file
diff --git a/tests/test_str_isrelational.c b/tests/test_str_isrelational.c
index 92c4803..8b5cce0 100644
--- a/tests/test_str_isrelational.c
+++ b/tests/test_str_isrelational.c
@@ -3,25 +3,25 @@
 
 const char *testFmt = "case: '%c': returned %d, expected %d\n";
 struct TestCase testCase[] = {
-        {.caseValue.character = '~', .truthValue.signed_integer = 1},
-        {.caseValue.character = '!', .truthValue.signed_integer = 1},
-        {.caseValue.character = '=', .truthValue.signed_integer = 1},
-        {.caseValue.character = '<', .truthValue.signed_integer = 1},
-        {.caseValue.character = '>', .truthValue.signed_integer = 1},
-        {.caseValue.character = 'u', .truthValue.signed_integer = 0},
-        {.caseValue.character = 'd', .truthValue.signed_integer = 0},
-        {.caseValue.character = 'l', .truthValue.signed_integer = 0},
-        {.caseValue.character = 'r', .truthValue.signed_integer = 0},
-        {.caseValue.character = 'b', .truthValue.signed_integer = 0},
-        {.caseValue.character = 'a', .truthValue.signed_integer = 0},
-        {.caseValue.character = '\n', .truthValue.signed_integer = 0},
+        {.caseValue.signed_char = '~', .truthValue.signed_int = 1},
+        {.caseValue.signed_char = '!', .truthValue.signed_int = 1},
+        {.caseValue.signed_char = '=', .truthValue.signed_int = 1},
+        {.caseValue.signed_char = '<', .truthValue.signed_int = 1},
+        {.caseValue.signed_char = '>', .truthValue.signed_int = 1},
+        {.caseValue.signed_char = 'u', .truthValue.signed_int = 0},
+        {.caseValue.signed_char = 'd', .truthValue.signed_int = 0},
+        {.caseValue.signed_char = 'l', .truthValue.signed_int = 0},
+        {.caseValue.signed_char = 'r', .truthValue.signed_int = 0},
+        {.caseValue.signed_char = 'b', .truthValue.signed_int = 0},
+        {.caseValue.signed_char = 'a', .truthValue.signed_int = 0},
+        {.caseValue.signed_char = '\n', .truthValue.signed_int = 0},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
 int main(int argc, char *argv[]) {
     for (size_t i = 0; i < numCases; i++) {
-        int result = isrelational(testCase[i].caseValue.character);
-        myassert(result == testCase[i].truthValue.signed_integer, testFmt, testCase[i].caseValue.character, result, testCase[i].truthValue.signed_integer);
+        int result = isrelational(testCase[i].caseValue.signed_char);
+        myassert(result == testCase[i].truthValue.signed_int, testFmt, testCase[i].caseValue.signed_char, result, testCase[i].truthValue.signed_int);
     }
     return 0;
 }
\ No newline at end of file
diff --git a/tests/test_str_num_chars_generic.c b/tests/test_str_num_chars_generic.c
index b5ae6a5..8f187c3 100644
--- a/tests/test_str_num_chars_generic.c
+++ b/tests/test_str_num_chars_generic.c
@@ -3,28 +3,28 @@
 
 const char *testFmt = "case '%s': returned %d, expected %d\n";
 struct TestCase testCase[] = {
-        {.inputValue.unsigned_integer = 'a', .caseValue.sptr = "after the world stops spinning", .truthValue.signed_integer = 1},
-        {.inputValue.unsigned_integer = 'a', .caseValue.sptr = "apples exploded all over the place", .truthValue.signed_integer = 3},
-        {.inputValue.unsigned_integer = 'a', .caseValue.sptr = "a1a2a3a4a z!z@z#z$z a5a6a7a8a9", .truthValue.signed_integer = 10},
-        {.inputValue.unsigned_integer = 'a', .caseValue.sptr = "aAaA", .truthValue.signed_integer = 2},
-        {.inputValue.unsigned_integer = 'A', .caseValue.sptr = "aAaA", .truthValue.signed_integer = 2},
-        {.inputValue.unsigned_integer = 'b', .caseValue.sptr = "abracadabra brisket gumball", .truthValue.signed_integer = 4},
-        {.inputValue.unsigned_integer = 'b', .caseValue.sptr = "balloons are falling from the sky", .truthValue.signed_integer = 1},
-        {.inputValue.unsigned_integer = 'b', .caseValue.sptr = "mangled mangoes oxidize quickly", .truthValue.signed_integer = 0},
-        {.inputValue.unsigned_integer = 'b', .caseValue.sptr = "bBbB", .truthValue.signed_integer = 2},
-        {.inputValue.unsigned_integer = 'B', .caseValue.sptr = "bBbB", .truthValue.signed_integer = 2},
+        {.inputValue.unsigned_int = 'a', .caseValue.sptr = "after the world stops spinning", .truthValue.signed_int = 1},
+        {.inputValue.unsigned_int = 'a', .caseValue.sptr = "apples exploded all over the place", .truthValue.signed_int = 3},
+        {.inputValue.unsigned_int = 'a', .caseValue.sptr = "a1a2a3a4a z!z@z#z$z a5a6a7a8a9", .truthValue.signed_int = 10},
+        {.inputValue.unsigned_int = 'a', .caseValue.sptr = "aAaA", .truthValue.signed_int = 2},
+        {.inputValue.unsigned_int = 'A', .caseValue.sptr = "aAaA", .truthValue.signed_int = 2},
+        {.inputValue.unsigned_int = 'b', .caseValue.sptr = "abracadabra brisket gumball", .truthValue.signed_int = 4},
+        {.inputValue.unsigned_int = 'b', .caseValue.sptr = "balloons are falling from the sky", .truthValue.signed_int = 1},
+        {.inputValue.unsigned_int = 'b', .caseValue.sptr = "mangled mangoes oxidize quickly", .truthValue.signed_int = 0},
+        {.inputValue.unsigned_int = 'b', .caseValue.sptr = "bBbB", .truthValue.signed_int = 2},
+        {.inputValue.unsigned_int = 'B', .caseValue.sptr = "bBbB", .truthValue.signed_int = 2},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
 
 int main(int argc, char *argv[]) {
     for (size_t i = 0; i < numCases; i++) {
-        int result = num_chars(testCase[i].caseValue.sptr, testCase[i].inputValue.unsigned_integer);
-        myassert(result == testCase[i].truthValue.signed_integer,
+        int result = num_chars(testCase[i].caseValue.sptr, testCase[i].inputValue.unsigned_int);
+        myassert(result == testCase[i].truthValue.signed_int,
                 testFmt,
                 testCase[i].caseValue.sptr,
                 result,
-                testCase[i].truthValue.signed_integer);
+                testCase[i].truthValue.signed_int);
     }
 
     return 0;
diff --git a/tests/test_str_startswith.c b/tests/test_str_startswith.c
index da25341..1346865 100644
--- a/tests/test_str_startswith.c
+++ b/tests/test_str_startswith.c
@@ -3,20 +3,20 @@
 
 const char *testFmt = "'%s' does not start with '%s' (%d)\n";
 struct TestCase testCase[] = {
-        {.inputValue.sptr = "abra", .caseValue.sptr = "abracadabra brisket gumball", .truthValue.signed_integer = 1},
-        {.inputValue.sptr = "ball", .caseValue.sptr = "balloons are falling from the sky", .truthValue.signed_integer = 1},
-        {.inputValue.sptr = "mangle", .caseValue.sptr = "mangled mangoes oxidize quickly", .truthValue.signed_integer = 1},
-        {.inputValue.sptr = "b", .caseValue.sptr = "bBbB", .truthValue.signed_integer = 1},
-        {.inputValue.sptr = NULL, .caseValue.sptr = "bBbB", .truthValue.signed_integer = -1},
-        {.inputValue.sptr = "test", .caseValue.sptr = NULL, .truthValue.signed_integer = -1},
-        {.inputValue.sptr = NULL, .caseValue.sptr = NULL, .truthValue.signed_integer = -1},
+        {.inputValue.sptr = "abra", .caseValue.sptr = "abracadabra brisket gumball", .truthValue.signed_int = 1},
+        {.inputValue.sptr = "ball", .caseValue.sptr = "balloons are falling from the sky", .truthValue.signed_int = 1},
+        {.inputValue.sptr = "mangle", .caseValue.sptr = "mangled mangoes oxidize quickly", .truthValue.signed_int = 1},
+        {.inputValue.sptr = "b", .caseValue.sptr = "bBbB", .truthValue.signed_int = 1},
+        {.inputValue.sptr = NULL, .caseValue.sptr = "bBbB", .truthValue.signed_int = -1},
+        {.inputValue.sptr = "test", .caseValue.sptr = NULL, .truthValue.signed_int = -1},
+        {.inputValue.sptr = NULL, .caseValue.sptr = NULL, .truthValue.signed_int = -1},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
 int main(int argc, char *argv[]) {
     for (size_t i = 0; i < numCases; i++) {
         int result = startswith(testCase[i].caseValue.sptr, testCase[i].inputValue.sptr);
-        myassert(result == testCase[i].truthValue.signed_integer, testFmt, testCase[i].inputValue.str, testCase[i].truthValue.sptr, result);
+        myassert(result == testCase[i].truthValue.signed_int, testFmt, testCase[i].inputValue.str, testCase[i].truthValue.sptr, result);
     }
     return 0;
 }
\ No newline at end of file
diff --git a/tests/test_str_strchroff.c b/tests/test_str_strchroff.c
index 805a96d..e8a6c0a 100644
--- a/tests/test_str_strchroff.c
+++ b/tests/test_str_strchroff.c
@@ -3,28 +3,28 @@
 
 const char *testFmt = "case '%s': returned %d, expected %d\n";
 struct TestCase testCase[] = {
-        {.inputValue.unsigned_integer = 'a', .caseValue.sptr = "after the world stops spinning", .truthValue.signed_integer = 0},
-        {.inputValue.unsigned_integer = 'p', .caseValue.sptr = "apples exploded all over the place", .truthValue.signed_integer = 1},
-        {.inputValue.unsigned_integer = '2', .caseValue.sptr = "a1a2a3a4a z!z@z#z$z a5a6a7a8a9", .truthValue.signed_integer = 3},
-        {.inputValue.unsigned_integer = 'a', .caseValue.sptr = "aAaA", .truthValue.signed_integer = 0},
-        {.inputValue.unsigned_integer = 'A', .caseValue.sptr = "aAaA", .truthValue.signed_integer = 1},
-        {.inputValue.unsigned_integer = 'g', .caseValue.sptr = "abracadabra brisket gumball", .truthValue.signed_integer = 20},
-        {.inputValue.unsigned_integer = 'r', .caseValue.sptr = "balloons are falling from the sky", .truthValue.signed_integer = 10},
-        {.inputValue.unsigned_integer = 'b', .caseValue.sptr = "mangled mangoes oxidize quickly", .truthValue.signed_integer = -1},
-        {.inputValue.unsigned_integer = 'b', .caseValue.sptr = "bBbB", .truthValue.signed_integer = 0},
-        {.inputValue.unsigned_integer = 'B', .caseValue.sptr = "bBbB", .truthValue.signed_integer = 1},
+        {.inputValue.unsigned_int = 'a', .caseValue.sptr = "after the world stops spinning", .truthValue.signed_int = 0},
+        {.inputValue.unsigned_int = 'p', .caseValue.sptr = "apples exploded all over the place", .truthValue.signed_int = 1},
+        {.inputValue.unsigned_int = '2', .caseValue.sptr = "a1a2a3a4a z!z@z#z$z a5a6a7a8a9", .truthValue.signed_int = 3},
+        {.inputValue.unsigned_int = 'a', .caseValue.sptr = "aAaA", .truthValue.signed_int = 0},
+        {.inputValue.unsigned_int = 'A', .caseValue.sptr = "aAaA", .truthValue.signed_int = 1},
+        {.inputValue.unsigned_int = 'g', .caseValue.sptr = "abracadabra brisket gumball", .truthValue.signed_int = 20},
+        {.inputValue.unsigned_int = 'r', .caseValue.sptr = "balloons are falling from the sky", .truthValue.signed_int = 10},
+        {.inputValue.unsigned_int = 'b', .caseValue.sptr = "mangled mangoes oxidize quickly", .truthValue.signed_int = -1},
+        {.inputValue.unsigned_int = 'b', .caseValue.sptr = "bBbB", .truthValue.signed_int = 0},
+        {.inputValue.unsigned_int = 'B', .caseValue.sptr = "bBbB", .truthValue.signed_int = 1},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
 
 int main(int argc, char *argv[]) {
     for (size_t i = 0; i < numCases; i++) {
-        int result = strchroff(testCase[i].caseValue.sptr, testCase[i].inputValue.unsigned_integer);
-        myassert(result == testCase[i].truthValue.signed_integer,
+        int result = strchroff(testCase[i].caseValue.sptr, testCase[i].inputValue.unsigned_int);
+        myassert(result == testCase[i].truthValue.signed_int,
                 testFmt,
                 testCase[i].caseValue.sptr,
                 result,
-                testCase[i].truthValue.signed_integer);
+                testCase[i].truthValue.signed_int);
     }
 
     return 0;
diff --git a/tests/test_str_strsort.c b/tests/test_str_strsort.c
index fbec04b..6447d01 100644
--- a/tests/test_str_strsort.c
+++ b/tests/test_str_strsort.c
@@ -3,16 +3,16 @@
 
 const char *testFmt = "case: (array){%s}: returned '%s', expected '%s'\n";
 struct TestCase testCase[] = {
-        {.inputValue.unsigned_integer = SPM_SORT_NUMERIC, .caseValue.slptr = (char *[]){"1", "100", "10", "10000", "1000", "0", NULL}, .truthValue.sptr = "0 1 10 100 1000 10000"},
-        {.inputValue.unsigned_integer = SPM_SORT_LEN_ASCENDING, .caseValue.slptr = (char *[]){"1", "100", "10", "10000", "1000", "0", NULL}, .truthValue.sptr = "1 0 10 100 1000 10000"}, // no QA?
-        {.inputValue.unsigned_integer = SPM_SORT_LEN_DESCENDING, .caseValue.slptr = (char *[]){"1", "100", "10", "10000", "1000", "0", NULL}, .truthValue.sptr = "10000 1000 100 10 1 0"},
-        {.inputValue.unsigned_integer = SPM_SORT_ALPHA, .caseValue.slptr = (char *[]){"c", "b", "a", NULL}, .truthValue.sptr = "a b c"},
-        {.inputValue.unsigned_integer = SPM_SORT_ALPHA, .caseValue.slptr = (char *[]){"a", "b", "c", NULL}, .truthValue.sptr = "a b c"},
-        {.inputValue.unsigned_integer = SPM_SORT_ALPHA, .caseValue.slptr = (char *[]){"3", "2", "1", NULL}, .truthValue.sptr = "1 2 3"},
-        {.inputValue.unsigned_integer = SPM_SORT_ALPHA, .caseValue.slptr = (char *[]){"1", "2", "3", NULL}, .truthValue.sptr = "1 2 3"},
-        {.inputValue.unsigned_integer = SPM_SORT_ALPHA, .caseValue.slptr = (char *[]){"package2", "package1", NULL}, .truthValue.sptr = "package1 package2"},
-        {.inputValue.unsigned_integer = SPM_SORT_ALPHA, .caseValue.slptr = (char *[]){"package1", "package2", NULL}, .truthValue.sptr = "package1 package2"},
-        {.inputValue.unsigned_integer = SPM_SORT_ALPHA, .caseValue.sptr = NULL, .truthValue.slptr = NULL},
+        {.inputValue.unsigned_int = SPM_SORT_NUMERIC, .caseValue.slptr = (char *[]){"1", "100", "10", "10000", "1000", "0", NULL}, .truthValue.sptr = "0 1 10 100 1000 10000"},
+        {.inputValue.unsigned_int = SPM_SORT_LEN_ASCENDING, .caseValue.slptr = (char *[]){"1", "100", "10", "10000", "1000", "0", NULL}, .truthValue.sptr = "1 0 10 100 1000 10000"}, // no QA?
+        {.inputValue.unsigned_int = SPM_SORT_LEN_DESCENDING, .caseValue.slptr = (char *[]){"1", "100", "10", "10000", "1000", "0", NULL}, .truthValue.sptr = "10000 1000 100 10 1 0"},
+        {.inputValue.unsigned_int = SPM_SORT_ALPHA, .caseValue.slptr = (char *[]){"c", "b", "a", NULL}, .truthValue.sptr = "a b c"},
+        {.inputValue.unsigned_int = SPM_SORT_ALPHA, .caseValue.slptr = (char *[]){"a", "b", "c", NULL}, .truthValue.sptr = "a b c"},
+        {.inputValue.unsigned_int = SPM_SORT_ALPHA, .caseValue.slptr = (char *[]){"3", "2", "1", NULL}, .truthValue.sptr = "1 2 3"},
+        {.inputValue.unsigned_int = SPM_SORT_ALPHA, .caseValue.slptr = (char *[]){"1", "2", "3", NULL}, .truthValue.sptr = "1 2 3"},
+        {.inputValue.unsigned_int = SPM_SORT_ALPHA, .caseValue.slptr = (char *[]){"package2", "package1", NULL}, .truthValue.sptr = "package1 package2"},
+        {.inputValue.unsigned_int = SPM_SORT_ALPHA, .caseValue.slptr = (char *[]){"package1", "package2", NULL}, .truthValue.sptr = "package1 package2"},
+        {.inputValue.unsigned_int = SPM_SORT_ALPHA, .caseValue.sptr = NULL, .truthValue.slptr = NULL},
 };
 size_t numCases = sizeof(testCase) / sizeof(struct TestCase);
 
@@ -21,7 +21,7 @@ int main(int argc, char *argv[]) {
         char **array_orig = strdup_array(testCase[i].caseValue.slptr);
         char **array_case = strdup_array(array_orig);
 
-        strsort(array_case, testCase[i].inputValue.unsigned_integer);
+        strsort(array_case, testCase[i].inputValue.unsigned_int);
         char *str_result = join(array_case, " ");
 
         if (testCase[i].truthValue.sptr == NULL && str_result == NULL) {