1 #include "common.h"
2 #include "vnstat_tests.h"
3 #include "datacache_tests.h"
4 #include "datacache.h"
5 
START_TEST(datacache_can_clear_empty_cache)6 START_TEST(datacache_can_clear_empty_cache)
7 {
8 	datacache *dc = NULL;
9 
10 	datacache_clear(&dc);
11 	ck_assert_ptr_eq(dc, NULL);
12 }
13 END_TEST
14 
START_TEST(datacache_can_add_to_cache)15 START_TEST(datacache_can_add_to_cache)
16 {
17 	int ret;
18 	datacache *dc = NULL;
19 
20 	ret = datacache_add(&dc, "eth0", 0);
21 	ck_assert_int_eq(ret, 1);
22 	ck_assert_str_eq(dc->interface, "eth0");
23 	ck_assert_int_eq(dc->active, 1);
24 	ck_assert_int_eq(dc->filled, 0);
25 	ck_assert_int_eq(dc->syncneeded, 0);
26 	ck_assert_int_eq(dc->currx, 0);
27 	ck_assert_int_eq(dc->curtx, 0);
28 	ck_assert_ptr_eq(dc->log, NULL);
29 	ck_assert_ptr_eq(dc->next, NULL);
30 
31 	datacache_clear(&dc);
32 	ck_assert_ptr_eq(dc, NULL);
33 }
34 END_TEST
35 
START_TEST(datacache_can_add_to_cache_consistently)36 START_TEST(datacache_can_add_to_cache_consistently)
37 {
38 	int ret;
39 	datacache *dc = NULL;
40 	datacache *bookmark = NULL;
41 
42 	ret = datacache_add(&dc, "eth0", 0);
43 	ck_assert_int_eq(ret, 1);
44 	ck_assert_str_eq(dc->interface, "eth0");
45 	ck_assert_int_eq(dc->active, 1);
46 	ck_assert_int_eq(dc->filled, 0);
47 	ck_assert_int_eq(dc->syncneeded, 0);
48 	ck_assert_int_eq(dc->currx, 0);
49 	ck_assert_int_eq(dc->curtx, 0);
50 	ck_assert_ptr_eq(dc->log, NULL);
51 	ck_assert_ptr_eq(dc->next, NULL);
52 
53 	bookmark = dc;
54 
55 	ret = datacache_add(&dc, "eth1", 0);
56 	ck_assert_int_eq(ret, 1);
57 
58 	ck_assert_str_eq(dc->interface, "eth1");
59 	ck_assert_int_eq(dc->active, 1);
60 	ck_assert_int_eq(dc->filled, 0);
61 	ck_assert_int_eq(dc->syncneeded, 0);
62 	ck_assert_int_eq(dc->currx, 0);
63 	ck_assert_int_eq(dc->curtx, 0);
64 	ck_assert_ptr_eq(dc->log, NULL);
65 	ck_assert_ptr_ne(dc->next, NULL);
66 
67 	ck_assert_str_eq(bookmark->interface, "eth0");
68 
69 	bookmark = dc;
70 	ck_assert_str_eq(bookmark->interface, "eth1");
71 
72 	bookmark = bookmark->next;
73 	ck_assert_str_eq(bookmark->interface, "eth0");
74 
75 	datacache_clear(&dc);
76 	ck_assert_ptr_eq(dc, NULL);
77 }
78 END_TEST
79 
START_TEST(datacache_knows_how_to_count)80 START_TEST(datacache_knows_how_to_count)
81 {
82 	int ret;
83 	datacache *dc = NULL;
84 
85 	ret = datacache_add(&dc, "eth0", 0);
86 	ck_assert_int_eq(ret, 1);
87 
88 	ret = datacache_count(&dc);
89 	ck_assert_int_eq(ret, 1);
90 
91 	ret = datacache_add(&dc, "eth1", 0);
92 	ck_assert_int_eq(ret, 1);
93 
94 	ret = datacache_count(&dc);
95 	ck_assert_int_eq(ret, 2);
96 
97 	ret = datacache_activecount(&dc);
98 	ck_assert_int_eq(ret, 2);
99 
100 	dc->active = 0;
101 
102 	ret = datacache_activecount(&dc);
103 	ck_assert_int_eq(ret, 1);
104 
105 	datacache_clear(&dc);
106 	ck_assert_ptr_eq(dc, NULL);
107 
108 	ret = datacache_count(&dc);
109 	ck_assert_int_eq(ret, 0);
110 
111 	ret = datacache_activecount(&dc);
112 	ck_assert_int_eq(ret, 0);
113 }
114 END_TEST
115 
START_TEST(datacache_can_remove)116 START_TEST(datacache_can_remove)
117 {
118 	int ret;
119 	datacache *dc = NULL;
120 
121 	ret = datacache_add(&dc, "eth0", 0);
122 	ck_assert_int_eq(ret, 1);
123 
124 	ret = datacache_add(&dc, "eth1", 0);
125 	ck_assert_int_eq(ret, 1);
126 
127 	ret = datacache_add(&dc, "eth2", 0);
128 	ck_assert_int_eq(ret, 1);
129 
130 	ret = datacache_add(&dc, "eth3", 0);
131 	ck_assert_int_eq(ret, 1);
132 
133 	ret = datacache_count(&dc);
134 	ck_assert_int_eq(ret, 4);
135 
136 	/* invalid removal doesn't cause issues */
137 	ret = datacache_remove(&dc, "eth4");
138 	ck_assert_int_eq(ret, 0);
139 	ret = datacache_count(&dc);
140 	ck_assert_int_eq(ret, 4);
141 	ck_assert_str_eq(dc->interface, "eth3");
142 
143 	/* head removal */
144 	ret = datacache_remove(&dc, "eth3");
145 	ck_assert_int_eq(ret, 1);
146 	ret = datacache_count(&dc);
147 	ck_assert_int_eq(ret, 3);
148 	ck_assert_str_eq(dc->interface, "eth2");
149 
150 	/* middle removal */
151 	ret = datacache_remove(&dc, "eth1");
152 	ck_assert_int_eq(ret, 1);
153 	ret = datacache_count(&dc);
154 	ck_assert_int_eq(ret, 2);
155 	ck_assert_str_eq(dc->interface, "eth2");
156 
157 	/* tail removal */
158 	ret = datacache_remove(&dc, "eth0");
159 	ck_assert_int_eq(ret, 1);
160 	ret = datacache_count(&dc);
161 	ck_assert_int_eq(ret, 1);
162 	ck_assert_str_eq(dc->interface, "eth2");
163 
164 	datacache_clear(&dc);
165 	ck_assert_ptr_eq(dc, NULL);
166 }
167 END_TEST
168 
START_TEST(datacache_can_do_stuff)169 START_TEST(datacache_can_do_stuff)
170 {
171 	int ret;
172 	datacache *dc = NULL;
173 
174 	ret = datacache_add(&dc, "eth0", 0);
175 	ck_assert_int_eq(ret, 1);
176 
177 	ret = datacache_add(&dc, "eth1", 0);
178 	ck_assert_int_eq(ret, 1);
179 
180 	ret = xferlog_add(&dc->log, 2, 1, 2);
181 	ck_assert_int_eq(ret, 1);
182 
183 	ret = xferlog_add(&dc->log, 2, 10, 15);
184 	ck_assert_int_eq(ret, 1);
185 
186 	ret = datacache_add(&dc, "eth2", 0);
187 	ck_assert_int_eq(ret, 1);
188 
189 	ret = datacache_add(&dc, "eth3", 0);
190 	ck_assert_int_eq(ret, 1);
191 
192 	ret = xferlog_add(&dc->log, 2, 2, 2);
193 	ck_assert_int_eq(ret, 1);
194 
195 	ret = datacache_count(&dc);
196 	ck_assert_int_eq(ret, 4);
197 
198 	/* suppress output to validate that debug function doesn't cause a crash */
199 	suppress_output();
200 	datacache_debug(&dc);
201 	printf("\n");
202 
203 	ret = datacache_remove(&dc, "eth1");
204 	ck_assert_int_eq(ret, 1);
205 	ret = datacache_count(&dc);
206 	ck_assert_int_eq(ret, 3);
207 
208 	datacache_debug(&dc);
209 	printf("\n");
210 
211 	datacache_clear(&dc);
212 	ck_assert_ptr_eq(dc, NULL);
213 	datacache_debug(&dc);
214 	ret = datacache_count(&dc);
215 	ck_assert_int_eq(ret, 0);
216 }
217 END_TEST
218 
START_TEST(xferlog_can_clear_empty_log)219 START_TEST(xferlog_can_clear_empty_log)
220 {
221 	xferlog *log = NULL;
222 
223 	xferlog_clear(&log);
224 	ck_assert_ptr_eq(log, NULL);
225 }
226 END_TEST
227 
START_TEST(xferlog_can_log)228 START_TEST(xferlog_can_log)
229 {
230 	int ret;
231 	xferlog *log = NULL;
232 
233 	ret = xferlog_add(&log, 1, 1, 1);
234 	ck_assert_int_eq(ret, 1);
235 
236 	ck_assert_ptr_ne(log, NULL);
237 
238 	xferlog_clear(&log);
239 	ck_assert_ptr_eq(log, NULL);
240 }
241 END_TEST
242 
START_TEST(xferlog_can_handle_multiple_entries)243 START_TEST(xferlog_can_handle_multiple_entries)
244 {
245 	int ret;
246 	xferlog *log = NULL;
247 	xferlog *bookmark = NULL;
248 
249 	ret = xferlog_add(&log, 1, 1, 1);
250 	ck_assert_int_eq(ret, 1);
251 	ck_assert_int_eq(log->timestamp, 1);
252 	ck_assert_int_eq(log->rx, 1);
253 	ck_assert_int_eq(log->tx, 1);
254 
255 	bookmark = log;
256 
257 	ret = xferlog_add(&log, 1, 1, 2);
258 	ck_assert_int_eq(ret, 1);
259 	ck_assert_int_eq(log->timestamp, 1);
260 	ck_assert_int_eq(log->rx, 2);
261 	ck_assert_int_eq(log->tx, 3);
262 
263 	ret = xferlog_add(&log, 4, 5, 5);
264 	ck_assert_int_eq(ret, 1);
265 	ck_assert_int_eq(log->timestamp, 4);
266 	ck_assert_int_eq(log->rx, 5);
267 	ck_assert_int_eq(log->tx, 5);
268 
269 	ret = xferlog_add(&log, 7, 4, 4);
270 	ck_assert_int_eq(ret, 1);
271 	ck_assert_int_eq(log->timestamp, 7);
272 	ck_assert_int_eq(log->rx, 4);
273 	ck_assert_int_eq(log->tx, 4);
274 
275 	ret = xferlog_add(&log, 1, 1, 1);
276 	ck_assert_int_eq(ret, 1);
277 	ck_assert_int_eq(log->timestamp, 1);
278 	ck_assert_int_eq(log->rx, 1);
279 	ck_assert_int_eq(log->tx, 1);
280 
281 	/* check that new addition with same timestamp doesn't modify old record */
282 	ck_assert_int_eq(bookmark->timestamp, 1);
283 	ck_assert_int_eq(bookmark->rx, 2);
284 	ck_assert_int_eq(bookmark->tx, 3);
285 
286 	xferlog_clear(&log);
287 	ck_assert_ptr_eq(log, NULL);
288 }
289 END_TEST
290 
add_datacache_tests(Suite * s)291 void add_datacache_tests(Suite *s)
292 {
293 	TCase *tc_datacache = tcase_create("Datacache");
294 	tcase_add_checked_fixture(tc_datacache, setup, teardown);
295 	tcase_add_unchecked_fixture(tc_datacache, setup, teardown);
296 	tcase_add_test(tc_datacache, datacache_can_clear_empty_cache);
297 	tcase_add_test(tc_datacache, datacache_can_add_to_cache);
298 	tcase_add_test(tc_datacache, datacache_can_add_to_cache_consistently);
299 	tcase_add_test(tc_datacache, datacache_knows_how_to_count);
300 	tcase_add_test(tc_datacache, datacache_can_remove);
301 	tcase_add_test(tc_datacache, datacache_can_do_stuff);
302 	tcase_add_test(tc_datacache, xferlog_can_clear_empty_log);
303 	tcase_add_test(tc_datacache, xferlog_can_log);
304 	tcase_add_test(tc_datacache, xferlog_can_handle_multiple_entries);
305 	suite_add_tcase(s, tc_datacache);
306 }
307