1. openvpn
  2. Commit 2ddb527abe38f5866ff01e91f8ee89d0f9700762
Browse code

buffer_list_aggregate_separator(): add unit tests

Before refactoring this function, add tests to verify the new
implementation.

While writing the tests, it became clear that this function is not
behaving very well. We'll fix that in follow-up commits.

Signed-off-by: Steffan Karger <steffan.karger@fox-it.com>
Acked-by: Gert Doering <gert@greenie.muc.de>
Message-Id: <20171104224551.3079-1-steffan@karger.me>
URL: https://www.mail-archive.com/openvpn-devel@lists.sourceforge.net/msg15748.html
Signed-off-by: Gert Doering <gert@greenie.muc.de>

Steffan Karger authored on 2017/11/05 07:45:50
Showing 1 changed files
tests/unit_tests/openvpn/test_buffer.c
History View file @ 2ddb527
... ... 
@@ -35,7 +35,7 @@
35 35 
 #include "buffer.h"
36 36
37 37 
 static void
38 
-buffer_strprefix(void **state)
38 
+test_buffer_strprefix(void **state)
39 39 
 {
40 40 
     assert_true(strprefix("123456", "123456"));
41 41 
     assert_true(strprefix("123456", "123"));
... ... 
@@ -44,11 +44,191 @@ buffer_strprefix(void **state)
44 44 
     assert_false(strprefix("12", "123"));
45 45 
 }
46 46
47 
+#define testsep ","
48 
+#define testnosep ""
49 
+#define teststr1 "one"
50 
+#define teststr2 "two"
51 
+#define teststr3 "three"
52 
+#define teststr4 "four"
53 
+
54 
+#define assert_buf_equals_str(buf, str) \
55 
+    assert_int_equal(BLEN(buf), strlen(str)); \
56 
+    assert_memory_equal(BPTR(buf), str, BLEN(buf));
57 
+
58 
+struct test_buffer_list_aggregate_ctx {
59 
+    struct buffer_list *empty;
60 
+    struct buffer_list *one_two_three;
61 
+    struct buffer_list *zero_length_strings;
62 
+    struct buffer_list *empty_buffers;
63 
+};
64 
+
65 
+static int test_buffer_list_setup(void **state)
66 
+{
67 
+    struct test_buffer_list_aggregate_ctx *ctx  = calloc(1, sizeof(*ctx));
68 
+    ctx->empty = buffer_list_new(0);
69 
+
70 
+    ctx->one_two_three = buffer_list_new(3);
71 
+    buffer_list_push(ctx->one_two_three, teststr1);
72 
+    buffer_list_push(ctx->one_two_three, teststr2);
73 
+    buffer_list_push(ctx->one_two_three, teststr3);
74 
+
75 
+    ctx->zero_length_strings = buffer_list_new(2);
76 
+    buffer_list_push(ctx->zero_length_strings, "");
77 
+    buffer_list_push(ctx->zero_length_strings, "");
78 
+
79 
+    ctx->empty_buffers = buffer_list_new(2);
80 
+    uint8_t *data1 = malloc(1);
81 
+    uint8_t *data2 = malloc(1);
82 
+    buffer_list_push_data(ctx->empty_buffers, data1, 0);
83 
+    buffer_list_push_data(ctx->empty_buffers, data2, 0);
84 
+
85 
+    *state = ctx;
86 
+    return 0;
87 
+}
88 
+
89 
+static int test_buffer_list_teardown(void **state)
90 
+{
91 
+    struct test_buffer_list_aggregate_ctx *ctx = *state;
92 
+
93 
+    buffer_list_free(ctx->empty);
94 
+    buffer_list_free(ctx->one_two_three);
95 
+    buffer_list_free(ctx->zero_length_strings);
96 
+    buffer_list_free(ctx->empty_buffers);
97 
+    free(ctx);
98 
+    return 0;
99 
+}
100 
+
101 
+static void
102 
+test_buffer_list_full(void **state)
103 
+{
104 
+    struct test_buffer_list_aggregate_ctx *ctx = *state;
105 
+
106 
+    /* list full */
107 
+    assert_int_equal(ctx->one_two_three->size, 3);
108 
+    buffer_list_push(ctx->one_two_three, teststr4);
109 
+    assert_int_equal(ctx->one_two_three->size, 3);
110 
+}
111 
+
112 
+static void
113 
+test_buffer_list_aggregate_separator_empty(void **state)
114 
+{
115 
+    struct test_buffer_list_aggregate_ctx *ctx = *state;
116 
+
117 
+    /* aggregating an empty buffer list results in an empty buffer list */
118 
+    buffer_list_aggregate_separator(ctx->empty, 3, testsep);
119 
+    assert_null(ctx->empty->head);
120 
+}
121 
+
122 
+static void
123 
+test_buffer_list_aggregate_separator_noop(void **state)
124 
+{
125 
+    struct test_buffer_list_aggregate_ctx *ctx = *state;
126 
+
127 
+    /* With a max length of 2, no aggregation should take place */
128 
+    buffer_list_aggregate_separator(ctx->one_two_three, 2, testsep);
129 
+    assert_int_equal(ctx->one_two_three->size, 3);
130 
+    struct buffer *buf = buffer_list_peek(ctx->one_two_three);
131 
+    assert_buf_equals_str(buf, teststr1);
132 
+}
133 
+
134 
+static void
135 
+test_buffer_list_aggregate_separator_two(void **state)
136 
+{
137 
+    struct test_buffer_list_aggregate_ctx *ctx = *state;
138 
+
139 
+    /* Aggregate the first two elements */
140 
+    /* FIXME this exceeds the supplied max */
141 
+    buffer_list_aggregate_separator(ctx->one_two_three, 4, testsep);
142 
+    /* FIXME size does not get adjusted after aggregating */
143 
+    assert_int_equal(ctx->one_two_three->size, 3);
144 
+    struct buffer *buf = buffer_list_peek(ctx->one_two_three);
145 
+    assert_buf_equals_str(buf, teststr1 testsep teststr2 testsep);
146 
+}
147 
+
148 
+static void
149 
+test_buffer_list_aggregate_separator_all(void **state)
150 
+{
151 
+    struct test_buffer_list_aggregate_ctx *ctx = *state;
152 
+
153 
+    /* Aggregate all */
154 
+    buffer_list_aggregate_separator(ctx->one_two_three, 1<<16, testsep);
155 
+    /* FIXME size does not get adjusted after aggregating */
156 
+    assert_int_equal(ctx->one_two_three->size, 3);
157 
+    struct buffer *buf = buffer_list_peek(ctx->one_two_three);
158 
+    assert_buf_equals_str(buf,
159 
+                          teststr1 testsep teststr2 testsep teststr3 testsep);
160 
+}
161 
+
162 
+static void
163 
+test_buffer_list_aggregate_separator_nosep(void **state)
164 
+{
165 
+    struct test_buffer_list_aggregate_ctx *ctx = *state;
166 
+
167 
+    /* Aggregate all */
168 
+    buffer_list_aggregate_separator(ctx->one_two_three, 1<<16, testnosep);
169 
+    /* FIXME size does not get adjusted after aggregating */
170 
+    assert_int_equal(ctx->one_two_three->size, 3);
171 
+    struct buffer *buf = buffer_list_peek(ctx->one_two_three);
172 
+    assert_buf_equals_str(buf, teststr1 teststr2 teststr3);
173 
+}
174 
+
175 
+static void
176 
+test_buffer_list_aggregate_separator_zerolen(void **state)
177 
+{
178 
+    struct test_buffer_list_aggregate_ctx *ctx = *state;
179 
+    struct buffer_list *bl_zerolen = ctx->zero_length_strings;
180 
+
181 
+    /* Aggregate all */
182 
+    buffer_list_aggregate_separator(bl_zerolen, 1<<16, testnosep);
183 
+    /* FIXME size does not get adjusted after aggregating */
184 
+    assert_int_equal(bl_zerolen->size, 2);
185 
+    struct buffer *buf = buffer_list_peek(bl_zerolen);
186 
+    assert_buf_equals_str(buf, "");
187 
+}
188 
+
189 
+static void
190 
+test_buffer_list_aggregate_separator_emptybuffers(void **state)
191 
+{
192 
+    struct test_buffer_list_aggregate_ctx *ctx = *state;
193 
+    struct buffer_list *bl_emptybuffers = ctx->empty_buffers;
194 
+
195 
+    /* Aggregate all */
196 
+    buffer_list_aggregate_separator(bl_emptybuffers, 1<<16, testnosep);
197 
+    /* FIXME size does not get adjusted after aggregating */
198 
+    assert_int_equal(bl_emptybuffers->size, 2);
199 
+    struct buffer *buf = buffer_list_peek(bl_emptybuffers);
200 
+    assert_int_equal(BLEN(buf), 0);
201 
+}
202 
+
47 203 
 int
48 204 
 main(void)
49 205 
 {
50 206 
     const struct CMUnitTest tests[] = {
51 
-        cmocka_unit_test(buffer_strprefix),
207 
+        cmocka_unit_test(test_buffer_strprefix),
208 
+        cmocka_unit_test_setup_teardown(test_buffer_list_full,
209 
+                                        test_buffer_list_setup,
210 
+                                        test_buffer_list_teardown),
211 
+        cmocka_unit_test_setup_teardown(test_buffer_list_aggregate_separator_empty,
212 
+                                        test_buffer_list_setup,
213 
+                                        test_buffer_list_teardown),
214 
+        cmocka_unit_test_setup_teardown(test_buffer_list_aggregate_separator_noop,
215 
+                                        test_buffer_list_setup,
216 
+                                        test_buffer_list_teardown),
217 
+        cmocka_unit_test_setup_teardown(test_buffer_list_aggregate_separator_two,
218 
+                                        test_buffer_list_setup,
219 
+                                        test_buffer_list_teardown),
220 
+        cmocka_unit_test_setup_teardown(test_buffer_list_aggregate_separator_all,
221 
+                                        test_buffer_list_setup,
222 
+                                        test_buffer_list_teardown),
223 
+        cmocka_unit_test_setup_teardown(test_buffer_list_aggregate_separator_nosep,
224 
+                                        test_buffer_list_setup,
225 
+                                        test_buffer_list_teardown),
226 
+        cmocka_unit_test_setup_teardown(test_buffer_list_aggregate_separator_zerolen,
227 
+                                        test_buffer_list_setup,
228 
+                                        test_buffer_list_teardown),
229 
+        cmocka_unit_test_setup_teardown(test_buffer_list_aggregate_separator_emptybuffers,
230 
+                                        test_buffer_list_setup,
231 
+                                        test_buffer_list_teardown),
52 232 
     };
53 233
54 234 
     return cmocka_run_group_tests_name("buffer", tests, NULL, NULL);