Refactor unit tests to simplify code for each test.

1 files changed, 83 insertions, 114 deletions

diff --git a/unittests.c b/unittests.c
index 4c3abf4..72b548c 100644
--- a/unittests.c
+++ b/unittests.c
@@ -27,6 +27,31 @@
     } while (0)
 
 
+#define MAX_STRINGS 128
+static Dynstr *strings[MAX_STRINGS];
+static int num_strings;
+
+static Dynstr *new_from_cstring(const char *cstring)
+{
+    Dynstr *dynstr;
+    
+    dynstr = dynstr_new_from_cstring(cstring);
+    if (num_strings < MAX_STRINGS) {
+        strings[num_strings] = dynstr;
+        num_strings++;
+    }
+    return dynstr;
+}
+
+static void free_all_strings(void)
+{
+    while (num_strings > 0) {
+        num_strings--;
+        dynstr_free(strings[num_strings]);
+    }
+}
+
+
 static int test_default_error_handler_is_indicate(void)
 {
     FAIL_UNLESS_EQUAL(dynstr_get_malloc_error_handler(),
@@ -201,14 +226,13 @@ static int test_creates_from_cstring(void)
     Dynstr *dynstr;
     size_t size;
     
-    dynstr = dynstr_new_from_cstring(bytes);
+    dynstr = new_from_cstring(bytes);
     FAIL_UNLESS_EQUAL(dynstr_len(dynstr), strlen(bytes));
 
     size = dynstr_memcpy(newbytes, dynstr, 0, strlen(bytes));
     FAIL_UNLESS_EQUAL(size, strlen(bytes));
     FAIL_UNLESS_EQUAL(memcmp(bytes, newbytes, strlen(bytes)), 0);
     
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -283,10 +307,9 @@ static int test_memcpy_returns_zero_if_offset_is_too_large(void)
     Dynstr *dynstr;
     char mem[1024];
     
-    dynstr = dynstr_new_from_cstring("hello");
+    dynstr = new_from_cstring("hello");
     FAIL_UNLESS_EQUAL(dynstr_memcpy(mem, dynstr, dynstr_len(dynstr), 1), 0);
     FAIL_UNLESS_EQUAL(dynstr_memcpy(mem, dynstr, dynstr_len(dynstr) + 1, 1), 0);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -297,11 +320,10 @@ static int test_memcpy_truncates_if_copying_too_much(void)
     char mem[1024];
     size_t len;
     
-    dynstr = dynstr_new_from_cstring("hello");
+    dynstr = new_from_cstring("hello");
     len = dynstr_len(dynstr);
     FAIL_UNLESS_EQUAL(dynstr_memcpy(mem, dynstr, 0, len), len);
     FAIL_UNLESS_EQUAL(dynstr_memcpy(mem, dynstr, 0, len + 1), len);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -313,11 +335,10 @@ static int test_memcpy_copies_whole_string_ok(void)
     char mem[1024];
     size_t len;
     
-    dynstr = dynstr_new_from_cstring(data);
+    dynstr = new_from_cstring(data);
     len = dynstr_len(dynstr);
     dynstr_memcpy(mem, dynstr, 0, len);
     FAIL_UNLESS_EQUAL(memcmp(data, mem, len), 0);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -329,11 +350,10 @@ static int test_memcpy_copies_substring_ok(void)
     char mem[1024];
     size_t len;
     
-    dynstr = dynstr_new_from_cstring(data);
+    dynstr = new_from_cstring(data);
     len = dynstr_len(dynstr);
     dynstr_memcpy(mem, dynstr, 1, len-2);
     FAIL_UNLESS_EQUAL(memcmp(data + 1, mem, len-2), 0);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -345,11 +365,10 @@ static int test_copies_empty_substring_ok(void)
     size_t size;
     char buf[1024];
     
-    dynstr = dynstr_new_from_cstring("abcdef");
+    dynstr = new_from_cstring("abcdef");
     sub = dynstr_substr(dynstr, 1, 0);
     size = dynstr_memcpy(buf, sub, 0, dynstr_len(sub));
     FAIL_UNLESS_EQUAL(size, 0);
-    dynstr_free(dynstr);
     dynstr_free(sub);
     return true;
 }
@@ -362,12 +381,11 @@ static int test_copies_single_byte_substring_ok(void)
     size_t size;
     char buf[1024];
     
-    dynstr = dynstr_new_from_cstring("abcdef");
+    dynstr = new_from_cstring("abcdef");
     sub = dynstr_substr(dynstr, 1, 1);
     size = dynstr_memcpy(buf, sub, 0, dynstr_len(sub));
     FAIL_UNLESS_EQUAL(size, 1);
     FAIL_UNLESS_EQUAL(memcmp(buf, "b", 1), 0);
-    dynstr_free(dynstr);
     dynstr_free(sub);
     return true;
 }
@@ -380,12 +398,11 @@ static int test_copies_middle_substring_ok(void)
     size_t size;
     char buf[1024];
     
-    dynstr = dynstr_new_from_cstring("abcdef");
+    dynstr = new_from_cstring("abcdef");
     sub = dynstr_substr(dynstr, 1, 4);
     size = dynstr_memcpy(buf, sub, 0, dynstr_len(sub));
     FAIL_UNLESS_EQUAL(size, 4);
     FAIL_UNLESS_EQUAL(memcmp(buf, "bcde", 4), 0);
-    dynstr_free(dynstr);
     dynstr_free(sub);
     return true;
 }
@@ -398,12 +415,11 @@ static int test_copies_initial_substring_ok(void)
     size_t size;
     char buf[1024];
     
-    dynstr = dynstr_new_from_cstring("abcdef");
+    dynstr = new_from_cstring("abcdef");
     sub = dynstr_substr(dynstr, 0, 5);
     size = dynstr_memcpy(buf, sub, 0, dynstr_len(sub));
     FAIL_UNLESS_EQUAL(size, 5);
     FAIL_UNLESS_EQUAL(memcmp(buf, "abcde", 5), 0);
-    dynstr_free(dynstr);
     dynstr_free(sub);
     return true;
 }
@@ -416,12 +432,11 @@ static int test_copies_final_substring_ok(void)
     size_t size;
     char buf[1024];
     
-    dynstr = dynstr_new_from_cstring("abcdef");
+    dynstr = new_from_cstring("abcdef");
     sub = dynstr_substr(dynstr, 1, 5);
     size = dynstr_memcpy(buf, sub, 0, dynstr_len(sub));
     FAIL_UNLESS_EQUAL(size, 5);
     FAIL_UNLESS_EQUAL(memcmp(buf, "bcdef", 5), 0);
-    dynstr_free(dynstr);
     dynstr_free(sub);
     return true;
 }
@@ -434,11 +449,10 @@ static int test_copies_empty_substring_when_offset_too_big(void)
     size_t size;
     char buf[1024];
     
-    dynstr = dynstr_new_from_cstring("abcdef");
+    dynstr = new_from_cstring("abcdef");
     sub = dynstr_substr(dynstr, 100, 1);
     size = dynstr_memcpy(buf, sub, 0, dynstr_len(sub));
     FAIL_UNLESS_EQUAL(size, 0);
-    dynstr_free(dynstr);
     dynstr_free(sub);
     return true;
 }
@@ -451,12 +465,11 @@ static int test_copies_partial_substring_when_length_too_big(void)
     size_t size;
     char buf[1024];
     
-    dynstr = dynstr_new_from_cstring("abcdef");
+    dynstr = new_from_cstring("abcdef");
     sub = dynstr_substr(dynstr, 1, 6);
     size = dynstr_memcpy(buf, sub, 0, dynstr_len(sub));
     FAIL_UNLESS_EQUAL(size, 5);
     FAIL_UNLESS_EQUAL(memcmp(buf, "bcdef", 5), 0);
-    dynstr_free(dynstr);
     dynstr_free(sub);
     return true;
 }
@@ -470,14 +483,12 @@ static int test_cats_ok(void)
     char buf[1024];
     size_t size;
     
-    a = dynstr_new_from_cstring("abc");
-    b = dynstr_new_from_cstring("def");
+    a = new_from_cstring("abc");
+    b = new_from_cstring("def");
     c = dynstr_cat(a, b, NULL);
     size = dynstr_memcpy(buf, c, 0, dynstr_len(c));
     FAIL_UNLESS_EQUAL(size, 6);
     FAIL_UNLESS_EQUAL(memcmp(buf, "abcdef", 6), 0);
-    dynstr_free(a);
-    dynstr_free(b);
     dynstr_free(c);
     return true;
 }
@@ -489,13 +500,11 @@ static int test_cat_returns_NULL_for_first_malloc_failure(void)
     Dynstr *b;
     Dynstr *c;
 
-    a = dynstr_new_from_cstring("abc");
-    b = dynstr_new_from_cstring("def");
+    a = new_from_cstring("abc");
+    b = new_from_cstring("def");
     dynstr_set_malloc(fail_malloc);
     c = dynstr_cat(a, b, NULL);
     FAIL_UNLESS_EQUAL(c, NULL);
-    dynstr_free(a);
-    dynstr_free(b);
     return true;
 }
 
@@ -506,14 +515,12 @@ static int test_cat_returns_NULL_for_second_malloc_failure(void)
     Dynstr *b;
     Dynstr *c;
 
-    a = dynstr_new_from_cstring("abc");
-    b = dynstr_new_from_cstring("def");
+    a = new_from_cstring("abc");
+    b = new_from_cstring("def");
     dynstr_set_malloc(fail_malloc);
     fail_malloc_after = 1;
     c = dynstr_cat(a, b, NULL);
     FAIL_UNLESS_EQUAL(c, NULL);
-    dynstr_free(a);
-    dynstr_free(b);
     return true;
 }
 
@@ -522,9 +529,8 @@ static int test_byteat_reports_correct_character(void)
 {
     Dynstr *dynstr;
     
-    dynstr = dynstr_new_from_cstring("abc");
+    dynstr = new_from_cstring("abc");
     FAIL_UNLESS_EQUAL(dynstr_byte_at(dynstr, 1), 'b');
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -533,9 +539,8 @@ static int test_byteat_reports_error_for_too_large_offset(void)
 {
     Dynstr *dynstr;
     
-    dynstr = dynstr_new_from_cstring("abc");
+    dynstr = new_from_cstring("abc");
     FAIL_UNLESS_EQUAL(dynstr_byte_at(dynstr, 1024), -1);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -544,9 +549,8 @@ static int test_byteat_reports_0xff_correctly(void)
 {
     Dynstr *dynstr;
     
-    dynstr = dynstr_new_from_cstring("\xff");
+    dynstr = new_from_cstring("\xff");
     FAIL_UNLESS_EQUAL(dynstr_byte_at(dynstr, 0), 255);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -556,10 +560,9 @@ static int test_first_byte_finds_byte(void)
     Dynstr *dynstr;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123456");
+    dynstr = new_from_cstring("123456");
     offset = dynstr_first_byte(dynstr, 0, '3');
     FAIL_UNLESS_EQUAL(offset, 2);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -569,10 +572,9 @@ static int test_first_byte_only_finds_first_byte(void)
     Dynstr *dynstr;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123123");
+    dynstr = new_from_cstring("123123");
     offset = dynstr_first_byte(dynstr, 0, '3');
     FAIL_UNLESS_EQUAL(offset, 2);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -582,10 +584,9 @@ static int test_first_byte_does_not_find_nonexistent_byte(void)
     Dynstr *dynstr;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123456");
+    dynstr = new_from_cstring("123456");
     offset = dynstr_first_byte(dynstr, 0, 'x');
     FAIL_UNLESS_EQUAL(offset, DYNSTR_NOT_FOUND);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -595,10 +596,9 @@ static int test_first_byte_does_not_find_byte_outside_range(void)
     Dynstr *dynstr;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123456");
+    dynstr = new_from_cstring("123456");
     offset = dynstr_first_byte(dynstr, 4, '3');
     FAIL_UNLESS_EQUAL(offset, DYNSTR_NOT_FOUND);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -608,10 +608,9 @@ static int test_first_byte_only_finds_byte_inside_range(void)
     Dynstr *dynstr;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123123");
+    dynstr = new_from_cstring("123123");
     offset = dynstr_first_byte(dynstr, 3, '3');
     FAIL_UNLESS_EQUAL(offset, 5);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -621,10 +620,9 @@ static int test_first_byte_does_not_find_in_range_outside_string(void)
     Dynstr *dynstr;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123123");
+    dynstr = new_from_cstring("123123");
     offset = dynstr_first_byte(dynstr, 128, '3');
     FAIL_UNLESS_EQUAL(offset, DYNSTR_NOT_FOUND);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -634,10 +632,9 @@ static int test_last_byte_finds_byte(void)
     Dynstr *dynstr;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123456");
+    dynstr = new_from_cstring("123456");
     offset = dynstr_last_byte(dynstr, 0, '3');
     FAIL_UNLESS_EQUAL(offset, 2);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -647,10 +644,9 @@ static int test_last_byte_only_finds_last_byte(void)
     Dynstr *dynstr;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123123");
+    dynstr = new_from_cstring("123123");
     offset = dynstr_last_byte(dynstr, 0, '3');
     FAIL_UNLESS_EQUAL(offset, 5);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -660,10 +656,9 @@ static int test_last_byte_does_not_find_nonexistent_byte(void)
     Dynstr *dynstr;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123456");
+    dynstr = new_from_cstring("123456");
     offset = dynstr_last_byte(dynstr, 0, 'x');
     FAIL_UNLESS_EQUAL(offset, DYNSTR_NOT_FOUND);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -673,10 +668,9 @@ static int test_last_byte_does_not_find_byte_outside_range(void)
     Dynstr *dynstr;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123456");
+    dynstr = new_from_cstring("123456");
     offset = dynstr_last_byte(dynstr, 4, '3');
     FAIL_UNLESS_EQUAL(offset, DYNSTR_NOT_FOUND);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -686,10 +680,9 @@ static int test_last_byte_only_finds_byte_inside_range(void)
     Dynstr *dynstr;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123123");
+    dynstr = new_from_cstring("123123");
     offset = dynstr_last_byte(dynstr, 3, '3');
     FAIL_UNLESS_EQUAL(offset, 5);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -699,10 +692,9 @@ static int test_last_byte_does_not_find_in_range_outside_string(void)
     Dynstr *dynstr;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123123");
+    dynstr = new_from_cstring("123123");
     offset = dynstr_last_byte(dynstr, 128, '3');
     FAIL_UNLESS_EQUAL(offset, DYNSTR_NOT_FOUND);
-    dynstr_free(dynstr);
     return true;
 }
 
@@ -713,12 +705,10 @@ static int test_first_string_finds_pattern(void)
     Dynstr *pattern;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123456");
-    pattern = dynstr_new_from_cstring("345");
+    dynstr = new_from_cstring("123456");
+    pattern = new_from_cstring("345");
     offset = dynstr_first_string(dynstr, 0, pattern);
     FAIL_UNLESS_EQUAL(offset, 2);
-    dynstr_free(dynstr);
-    dynstr_free(pattern);
     return true;
 }
 
@@ -729,12 +719,10 @@ static int test_first_string_only_finds_first_pattern(void)
     Dynstr *pattern;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123123");
-    pattern = dynstr_new_from_cstring("123");
+    dynstr = new_from_cstring("123123");
+    pattern = new_from_cstring("123");
     offset = dynstr_first_string(dynstr, 0, pattern);
     FAIL_UNLESS_EQUAL(offset, 0);
-    dynstr_free(dynstr);
-    dynstr_free(pattern);
     return true;
 }
 
@@ -745,12 +733,10 @@ static int test_first_string_does_not_find_nonexistent_pattern(void)
     Dynstr *pattern;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123456");
-    pattern = dynstr_new_from_cstring("x");
+    dynstr = new_from_cstring("123456");
+    pattern = new_from_cstring("x");
     offset = dynstr_first_string(dynstr, 0, pattern);
     FAIL_UNLESS_EQUAL(offset, DYNSTR_NOT_FOUND);
-    dynstr_free(dynstr);
-    dynstr_free(pattern);
     return true;
 }
 
@@ -761,12 +747,10 @@ static int test_first_string_does_not_find_pattern_outside_range(void)
     Dynstr *pattern;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123456");
-    pattern = dynstr_new_from_cstring("123");
+    dynstr = new_from_cstring("123456");
+    pattern = new_from_cstring("123");
     offset = dynstr_first_string(dynstr, 3, pattern);
     FAIL_UNLESS_EQUAL(offset, DYNSTR_NOT_FOUND);
-    dynstr_free(dynstr);
-    dynstr_free(pattern);
     return true;
 }
 
@@ -777,12 +761,10 @@ static int test_first_string_only_finds_pattern_inside_range(void)
     Dynstr *pattern;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123123");
-    pattern = dynstr_new_from_cstring("3");
+    dynstr = new_from_cstring("123123");
+    pattern = new_from_cstring("3");
     offset = dynstr_first_string(dynstr, 3, pattern);
     FAIL_UNLESS_EQUAL(offset, 5);
-    dynstr_free(dynstr);
-    dynstr_free(pattern);
     return true;
 }
 
@@ -793,12 +775,10 @@ static int test_first_string_does_not_find_empty_pattern(void)
     Dynstr *pattern;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123123");
-    pattern = dynstr_new_from_cstring("");
+    dynstr = new_from_cstring("123123");
+    pattern = new_from_cstring("");
     offset = dynstr_first_string(dynstr, 0, pattern);
     FAIL_UNLESS_EQUAL(offset, DYNSTR_NOT_FOUND);
-    dynstr_free(dynstr);
-    dynstr_free(pattern);
     return true;
 }
 
@@ -809,12 +789,10 @@ static int test_last_string_finds_pattern(void)
     Dynstr *pattern;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123456");
-    pattern = dynstr_new_from_cstring("345");
+    dynstr = new_from_cstring("123456");
+    pattern = new_from_cstring("345");
     offset = dynstr_last_string(dynstr, 0, pattern);
     FAIL_UNLESS_EQUAL(offset, 2);
-    dynstr_free(dynstr);
-    dynstr_free(pattern);
     return true;
 }
 
@@ -825,12 +803,10 @@ static int test_last_string_only_finds_last_pattern(void)
     Dynstr *pattern;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123123");
-    pattern = dynstr_new_from_cstring("123");
+    dynstr = new_from_cstring("123123");
+    pattern = new_from_cstring("123");
     offset = dynstr_last_string(dynstr, 0, pattern);
     FAIL_UNLESS_EQUAL(offset, 3);
-    dynstr_free(dynstr);
-    dynstr_free(pattern);
     return true;
 }
 
@@ -841,12 +817,10 @@ static int test_last_string_does_not_find_nonexistent_pattern(void)
     Dynstr *pattern;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123456");
-    pattern = dynstr_new_from_cstring("x");
+    dynstr = new_from_cstring("123456");
+    pattern = new_from_cstring("x");
     offset = dynstr_last_string(dynstr, 0, pattern);
     FAIL_UNLESS_EQUAL(offset, DYNSTR_NOT_FOUND);
-    dynstr_free(dynstr);
-    dynstr_free(pattern);
     return true;
 }
 
@@ -857,12 +831,10 @@ static int test_last_string_does_not_find_pattern_outside_range(void)
     Dynstr *pattern;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123456");
-    pattern = dynstr_new_from_cstring("123");
+    dynstr = new_from_cstring("123456");
+    pattern = new_from_cstring("123");
     offset = dynstr_last_string(dynstr, 3, pattern);
     FAIL_UNLESS_EQUAL(offset, DYNSTR_NOT_FOUND);
-    dynstr_free(dynstr);
-    dynstr_free(pattern);
     return true;
 }
 
@@ -873,12 +845,10 @@ static int test_last_string_only_finds_pattern_inside_range(void)
     Dynstr *pattern;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123123");
-    pattern = dynstr_new_from_cstring("3");
+    dynstr = new_from_cstring("123123");
+    pattern = new_from_cstring("3");
     offset = dynstr_last_string(dynstr, 3, pattern);
     FAIL_UNLESS_EQUAL(offset, 5);
-    dynstr_free(dynstr);
-    dynstr_free(pattern);
     return true;
 }
 
@@ -889,12 +859,10 @@ static int test_last_string_does_not_find_empty_pattern(void)
     Dynstr *pattern;
     size_t offset;
     
-    dynstr = dynstr_new_from_cstring("123123");
-    pattern = dynstr_new_from_cstring("");
+    dynstr = new_from_cstring("123123");
+    pattern = new_from_cstring("");
     offset = dynstr_last_string(dynstr, 0, pattern);
     FAIL_UNLESS_EQUAL(offset, DYNSTR_NOT_FOUND);
-    dynstr_free(dynstr);
-    dynstr_free(pattern);
     return true;
 }
 
@@ -908,6 +876,7 @@ static void setup(void)
 
 static void teardown(void)
 {
+    free_all_strings();
 }