Debian Codegraph @

tests/test_nwrap_vector.c

raw
1 #include "config.h"
2
3 #include <stdarg.h>
4 #include <stddef.h>
5 #include <setjmp.h>
6 #include <cmocka.h>
7
8 #include "../src/nss_wrapper.c"
9
10 static void test_nwrap_vector_basic_add(void **state)
11 {
12 struct nwrap_vector v;
13 char string[] = "string!";
14 char string2[] = "2string!";
15
16 (void) state; /* unused */
17
18 nwrap_vector_init(&v);
19 assert_non_null(v.items);
20
21 nwrap_vector_add_item(&v, string);
22 assert_null(v.items[1]);
23 assert_int_equal(v.count, 1);
24 assert_string_equal(v.items[0], string);
25 assert_int_equal(v.capacity, DEFAULT_VECTOR_CAPACITY);
26
27 assert_string_equal(v.items[0], "string!");
28
29 nwrap_vector_add_item(&v, string2);
30 assert_null(v.items[2]);
31 assert_int_equal(v.count, 2);
32 assert_string_equal(v.items[0], string);
33 assert_string_equal(v.items[1], string2);
34
35 free(v.items);
36 }
37
38 static void test_nwrap_vector_merge_empty(void **state)
39 {
40 struct nwrap_vector v1;
41 struct nwrap_vector v2;
42 char string[] = "string!";
43 char string2[] = "2string!";
44
45 (void) state; /* unused */
46
47 nwrap_vector_init(&v1);
48 assert_non_null(v1.items);
49 assert_int_equal(v1.count, 0);
50
51 nwrap_vector_init(&v2);
52 assert_non_null(v2.items);
53 assert_int_equal(v2.count, 0);
54
55 nwrap_vector_merge(&v1, &v2);
56 assert_int_equal(v1.count, 0);
57 assert_null(v1.items[0]);
58
59 nwrap_vector_add_item(&v1, string);
60 nwrap_vector_add_item(&v1, string2);
61 assert_int_equal(v1.count, 2);
62
63 nwrap_vector_merge(&v1, &v2);
64 assert_int_equal(v1.count, 2);
65 assert_string_equal(v1.items[0], string);
66 assert_string_equal(v1.items[1], string2);
67 assert_null(v1.items[2]);
68
69 nwrap_vector_merge(&v2, &v1);
70 assert_int_equal(v2.count, 2);
71 assert_string_equal(v2.items[0], string);
72 assert_string_equal(v2.items[1], string2);
73 assert_null(v2.items[2]);
74
75 free(v1.items);
76 free(v2.items);
77 }
78
79 static void test_nwrap_vector_merge(void **state)
80 {
81 struct nwrap_vector v1;
82 struct nwrap_vector v2;
83 char string[] = "string!";
84 char string2[] = "2string!";
85
86 (void) state; /* unused */
87
88 nwrap_vector_init(&v1);
89 assert_non_null(v1.items);
90 nwrap_vector_add_item(&v1, string);
91 nwrap_vector_add_item(&v1, string2);
92 assert_int_equal(v1.count, 2);
93
94 nwrap_vector_init(&v2);
95 assert_non_null(v2.items);
96 nwrap_vector_add_item(&v2, string2);
97 nwrap_vector_add_item(&v2, string);
98 assert_int_equal(v2.count, 2);
99
100 nwrap_vector_merge(&v1, &v2);
101 assert_int_equal(v1.count, 4);
102 assert_string_equal(v1.items[0], string);
103 assert_string_equal(v1.items[1], string2);
104 assert_string_equal(v1.items[2], string2);
105 assert_string_equal(v1.items[3], string);
106 assert_null(v1.items[4]);
107
108 free(v1.items);
109 free(v2.items);
110 }
111
112 static void test_nwrap_vector_merge_max(void **state)
113 {
114 struct nwrap_vector v1;
115 struct nwrap_vector v2;
116 char string[] = "string!";
117 char string2[] = "2string!";
118 int p;
119
120 (void) state; /* unused */
121
122 nwrap_vector_init(&v1);
123 assert_non_null(v1.items);
124
125 for (p = 0; p < 64; ++p) {
126 nwrap_vector_add_item(&v1, string);
127 }
128 assert_int_equal(v1.count, 64);
129
130 nwrap_vector_init(&v2);
131 assert_non_null(v2.items);
132
133 nwrap_vector_merge(&v2, &v1);
134 assert_int_equal(v2.count, 64);
135 for (p = 0; p < 64; ++p) {
136 assert_string_equal(v2.items[p], string);
137 }
138
139 nwrap_vector_add_item(&v2, string2);
140 assert_string_equal(v2.items[64], string2);
141 assert_int_equal(v2.count, 65);
142 assert_null(v2.items[65]);
143
144 free(v1.items);
145 free(v2.items);
146 }
147
148 int main(void) {
149 int rc;
150
151 const struct CMUnitTest tests[] = {
152 cmocka_unit_test(test_nwrap_vector_basic_add),
153 cmocka_unit_test(test_nwrap_vector_merge_empty),
154 cmocka_unit_test(test_nwrap_vector_merge),
155 cmocka_unit_test(test_nwrap_vector_merge_max),
156 };
157
158 rc = cmocka_run_group_tests(tests, NULL, NULL);
159
160 return rc;
161 }
162