1 /*
2 * Copyright (c) 2014 Jerry Lundström <lundstrom.jerry@gmail.com>
3 * Copyright (c) 2014 .SE (The Internet Infrastructure Foundation).
4 * Copyright (c) 2014 OpenDNSSEC AB (svb)
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
20 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
22 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
24 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
25 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 */
29
30 #include "../db_backend.h"
31 #include "../db_clause.h"
32 #include "../db_configuration.h"
33 #include "../db_connection.h"
34 #include "../db_join.h"
35 #include "../db_object.h"
36 #include "../db_result.h"
37 #include "../db_value.h"
38
39 #include "CUnit/Basic.h"
40
41 static int fake_pointer = 0;
42 static db_backend_handle_t* backend_handle = NULL;
43 static db_backend_t* backend = NULL;
44 static db_clause_t* clause = NULL;
45 static db_clause_t* clause2 = NULL;
46 static db_clause_list_t* clause_list = NULL;
47 static db_configuration_t* configuration = NULL;
48 static db_configuration_t* configuration2 = NULL;
49 static db_configuration_list_t* configuration_list = NULL;
50 static db_connection_t* connection = NULL;
51 static db_join_t* join = NULL;
52 static db_join_t* join2 = NULL;
53 static db_join_list_t* join_list = NULL;
54 static db_object_field_t* object_field = NULL;
55 static db_object_field_t* object_field2 = NULL;
56 static db_object_field_list_t* object_field_list = NULL;
57 static db_object_t* object = NULL;
58 static db_value_set_t* value_set = NULL;
59 static db_value_set_t* value_set2 = NULL;
60 static db_result_t* result = NULL;
61 static db_result_t* result2 = NULL;
62 static db_result_list_t* result_list = NULL;
63 static db_value_t* value = NULL;
64 static db_value_t* value2 = NULL;
65 static const db_enum_t enum_set[] = {
66 { "enum1", 1 },
67 { "enum2", 2 },
68 { "enum3", 3 },
69 { NULL, 0 }
70 };
71
init_suite_classes(void)72 int init_suite_classes(void) {
73 if (backend_handle) {
74 return 1;
75 }
76 if (backend) {
77 return 1;
78 }
79 if (clause) {
80 return 1;
81 }
82 if (clause2) {
83 return 1;
84 }
85 if (clause_list) {
86 return 1;
87 }
88 if (configuration) {
89 return 1;
90 }
91 if (configuration2) {
92 return 1;
93 }
94 if (configuration_list) {
95 return 1;
96 }
97 if (connection) {
98 return 1;
99 }
100 if (join) {
101 return 1;
102 }
103 if (join2) {
104 return 1;
105 }
106 if (join_list) {
107 return 1;
108 }
109 if (object_field) {
110 return 1;
111 }
112 if (object_field2) {
113 return 1;
114 }
115 if (object_field_list) {
116 return 1;
117 }
118 if (object) {
119 return 1;
120 }
121 if (value_set) {
122 return 1;
123 }
124 if (value_set2) {
125 return 1;
126 }
127 if (result) {
128 return 1;
129 }
130 if (result2) {
131 return 1;
132 }
133 if (result_list) {
134 return 1;
135 }
136 if (value) {
137 return 1;
138 }
139 if (value2) {
140 return 1;
141 }
142 return 0;
143 }
144
clean_suite_classes(void)145 int clean_suite_classes(void) {
146 db_backend_handle_free(backend_handle);
147 backend_handle = NULL;
148 db_backend_free(backend);
149 backend = NULL;
150 db_clause_free(clause);
151 clause = NULL;
152 db_clause_free(clause2);
153 clause2 = NULL;
154 db_clause_list_free(clause_list);
155 clause_list = NULL;
156 db_configuration_free(configuration);
157 configuration = NULL;
158 db_configuration_free(configuration2);
159 configuration2 = NULL;
160 db_configuration_list_free(configuration_list);
161 configuration_list = NULL;
162 db_connection_free(connection);
163 connection = NULL;
164 db_object_field_free(object_field);
165 object_field = NULL;
166 db_object_field_free(object_field2);
167 object_field2 = NULL;
168 db_object_field_list_free(object_field_list);
169 object_field_list = NULL;
170 db_object_free(object);
171 object = NULL;
172 db_value_set_free(value_set);
173 value_set = NULL;
174 db_value_set_free(value_set2);
175 value_set2 = NULL;
176 db_result_free(result);
177 result = NULL;
178 db_result_free(result2);
179 result2 = NULL;
180 db_result_list_free(result_list);
181 result_list = NULL;
182 db_value_free(value);
183 value = NULL;
184 db_value_free(value2);
185 value2 = NULL;
186 return 0;
187 }
188
__db_backend_handle_initialize(void * data)189 int __db_backend_handle_initialize(void* data) {
190 CU_ASSERT(data == &fake_pointer);
191 return 0;
192 }
193
__db_backend_handle_shutdown(void * data)194 int __db_backend_handle_shutdown(void* data) {
195 CU_ASSERT(data == &fake_pointer);
196 return 0;
197 }
198
__db_backend_handle_connect(void * data,const db_configuration_list_t * configuration_list)199 int __db_backend_handle_connect(void* data, const db_configuration_list_t* configuration_list) {
200 CU_ASSERT(data == &fake_pointer);
201 CU_ASSERT((void*)configuration_list == &fake_pointer);
202 return 0;
203 }
204
__db_backend_handle_disconnect(void * data)205 int __db_backend_handle_disconnect(void* data) {
206 CU_ASSERT(data == &fake_pointer);
207 return 0;
208 }
209
__db_backend_handle_create(void * data,const db_object_t * _object,const db_object_field_list_t * object_field_list,const db_value_set_t * value_set)210 int __db_backend_handle_create(void* data, const db_object_t* _object, const db_object_field_list_t* object_field_list, const db_value_set_t* value_set) {
211 CU_ASSERT(data == &fake_pointer);
212 CU_ASSERT((void*)_object == &fake_pointer || (object != NULL && _object == object));
213 CU_ASSERT((void*)object_field_list == &fake_pointer);
214 CU_ASSERT((void*)value_set == &fake_pointer);
215 return 0;
216 }
217
__db_backend_handle_read(void * data,const db_object_t * _object,const db_join_list_t * join_list,const db_clause_list_t * clause_list)218 db_result_list_t* __db_backend_handle_read(void* data, const db_object_t* _object, const db_join_list_t* join_list, const db_clause_list_t* clause_list) {
219 CU_ASSERT(data == &fake_pointer);
220 CU_ASSERT((void*)_object == &fake_pointer || (object != NULL && _object == object));
221 CU_ASSERT((void*)join_list == &fake_pointer);
222 CU_ASSERT((void*)clause_list == &fake_pointer);
223 return (db_result_list_t*)&fake_pointer;
224 }
225
__db_backend_handle_update(void * data,const db_object_t * _object,const db_object_field_list_t * object_field_list,const db_value_set_t * value_set,const db_clause_list_t * clause_list)226 int __db_backend_handle_update(void* data, const db_object_t* _object, const db_object_field_list_t* object_field_list, const db_value_set_t* value_set, const db_clause_list_t* clause_list) {
227 CU_ASSERT(data == &fake_pointer);
228 CU_ASSERT((void*)_object == &fake_pointer || (object != NULL && _object == object));
229 CU_ASSERT((void*)object_field_list == &fake_pointer);
230 CU_ASSERT((void*)value_set == &fake_pointer);
231 CU_ASSERT((void*)clause_list == &fake_pointer);
232 return 0;
233 }
234
__db_backend_handle_delete(void * data,const db_object_t * _object,const db_clause_list_t * clause_list)235 int __db_backend_handle_delete(void* data, const db_object_t* _object, const db_clause_list_t* clause_list) {
236 CU_ASSERT(data == &fake_pointer);
237 CU_ASSERT((void*)_object == &fake_pointer || (object != NULL && _object == object));
238 CU_ASSERT((void*)clause_list == &fake_pointer);
239 return 0;
240 }
241
__db_backend_handle_count(void * data,const db_object_t * _object,const db_join_list_t * join_list,const db_clause_list_t * clause_list,size_t * count)242 int __db_backend_handle_count(void* data, const db_object_t* _object, const db_join_list_t* join_list, const db_clause_list_t* clause_list, size_t* count) {
243 CU_ASSERT(data == &fake_pointer);
244 CU_ASSERT((void*)_object == &fake_pointer || (object != NULL && _object == object));
245 CU_ASSERT((void*)join_list == &fake_pointer);
246 CU_ASSERT((void*)clause_list == &fake_pointer);
247 CU_ASSERT((void*)count == &fake_pointer);
248 return 0;
249 }
250
__db_backend_handle_free(void * data)251 void __db_backend_handle_free(void* data) {
252 CU_ASSERT(data == &fake_pointer);
253 }
254
__db_backend_handle_transaction_begin(void * data)255 int __db_backend_handle_transaction_begin(void* data) {
256 CU_ASSERT(data == &fake_pointer);
257 return 0;
258 }
259
__db_backend_handle_transaction_commit(void * data)260 int __db_backend_handle_transaction_commit(void* data) {
261 CU_ASSERT(data == &fake_pointer);
262 return 0;
263 }
264
__db_backend_handle_transaction_rollback(void * data)265 int __db_backend_handle_transaction_rollback(void* data) {
266 CU_ASSERT(data == &fake_pointer);
267 return 0;
268 }
269
test_class_db_backend_handle(void)270 void test_class_db_backend_handle(void) {
271 CU_ASSERT_PTR_NOT_NULL_FATAL((backend_handle = db_backend_handle_new()));
272
273 CU_ASSERT(!db_backend_handle_set_initialize(backend_handle, __db_backend_handle_initialize));
274 CU_ASSERT(!db_backend_handle_set_shutdown(backend_handle, __db_backend_handle_shutdown));
275 CU_ASSERT(!db_backend_handle_set_connect(backend_handle, __db_backend_handle_connect));
276 CU_ASSERT(!db_backend_handle_set_disconnect(backend_handle, __db_backend_handle_disconnect));
277 CU_ASSERT(!db_backend_handle_set_create(backend_handle, __db_backend_handle_create));
278 CU_ASSERT(!db_backend_handle_set_read(backend_handle, __db_backend_handle_read));
279 CU_ASSERT(!db_backend_handle_set_update(backend_handle, __db_backend_handle_update));
280 CU_ASSERT(!db_backend_handle_set_delete(backend_handle, __db_backend_handle_delete));
281 CU_ASSERT(!db_backend_handle_set_count(backend_handle, __db_backend_handle_count));
282 CU_ASSERT(!db_backend_handle_set_free(backend_handle, __db_backend_handle_free));
283 CU_ASSERT(!db_backend_handle_set_transaction_begin(backend_handle, __db_backend_handle_transaction_begin));
284 CU_ASSERT(!db_backend_handle_set_transaction_commit(backend_handle, __db_backend_handle_transaction_commit));
285 CU_ASSERT(!db_backend_handle_set_transaction_rollback(backend_handle, __db_backend_handle_transaction_rollback));
286 CU_ASSERT(!db_backend_handle_set_data(backend_handle, &fake_pointer));
287
288 CU_ASSERT(!db_backend_handle_connect(backend_handle, (db_configuration_list_t*)&fake_pointer));
289 CU_ASSERT(!db_backend_handle_create(backend_handle, (db_object_t*)&fake_pointer, (db_object_field_list_t*)&fake_pointer, (db_value_set_t*)&fake_pointer));
290 CU_ASSERT(db_backend_handle_read(backend_handle, (db_object_t*)&fake_pointer, (db_join_list_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer) == (db_result_list_t*)&fake_pointer);
291 CU_ASSERT(!db_backend_handle_update(backend_handle, (db_object_t*)&fake_pointer, (db_object_field_list_t*)&fake_pointer, (db_value_set_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer));
292 CU_ASSERT(!db_backend_handle_delete(backend_handle, (db_object_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer));
293 CU_ASSERT(!db_backend_handle_count(backend_handle, (db_object_t*)&fake_pointer, (db_join_list_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer, (size_t*)&fake_pointer));
294 }
295
test_class_db_backend(void)296 void test_class_db_backend(void) {
297 CU_ASSERT_PTR_NOT_NULL_FATAL((backend = db_backend_new()));
298 CU_ASSERT(!db_backend_set_name(backend, "test"));
299 CU_ASSERT_FATAL(!db_backend_set_handle(backend, backend_handle));
300 backend_handle = NULL;
301
302 CU_ASSERT(!db_backend_initialize(backend));
303 CU_ASSERT(!db_backend_connect(backend, (db_configuration_list_t*)&fake_pointer));
304 CU_ASSERT(!db_backend_create(backend, (db_object_t*)&fake_pointer, (db_object_field_list_t*)&fake_pointer, (db_value_set_t*)&fake_pointer));
305 CU_ASSERT(db_backend_read(backend, (db_object_t*)&fake_pointer, (db_join_list_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer) == (db_result_list_t*)&fake_pointer);
306 CU_ASSERT(!db_backend_update(backend, (db_object_t*)&fake_pointer, (db_object_field_list_t*)&fake_pointer, (db_value_set_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer));
307 CU_ASSERT(!db_backend_delete(backend, (db_object_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer));
308 CU_ASSERT(!db_backend_count(backend, (db_object_t*)&fake_pointer, (db_join_list_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer, (size_t*)&fake_pointer));
309 }
310
test_class_db_clause(void)311 void test_class_db_clause(void) {
312 CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
313
314 CU_ASSERT(!db_clause_set_field(clause, "field"));
315 CU_ASSERT(!db_clause_set_type(clause, DB_CLAUSE_NOT_EQUAL));
316 CU_ASSERT(!db_clause_set_operator(clause, DB_CLAUSE_OPERATOR_OR));
317 CU_ASSERT_PTR_NOT_NULL_FATAL(db_clause_get_value(clause));
318 CU_ASSERT(!db_value_from_int32(db_clause_get_value(clause), 1));
319 CU_ASSERT(!db_clause_not_empty(clause));
320
321 CU_ASSERT_PTR_NOT_NULL_FATAL(db_clause_field(clause));
322 CU_ASSERT(!strcmp(db_clause_field(clause), "field"));
323 CU_ASSERT(db_clause_type(clause) == DB_CLAUSE_NOT_EQUAL);
324 CU_ASSERT(db_clause_operator(clause) == DB_CLAUSE_OPERATOR_OR);
325 CU_ASSERT_PTR_NOT_NULL(db_clause_value(clause));
326 CU_ASSERT_PTR_NULL(db_clause_next(clause));
327 }
328
test_class_db_clause_list(void)329 void test_class_db_clause_list(void) {
330 db_clause_t* local_clause = clause;
331 const db_clause_t* clause_walk;
332
333 CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
334
335 CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
336 clause = NULL;
337
338 CU_ASSERT((clause_walk = db_clause_list_begin(clause_list)) == local_clause);
339
340 db_clause_list_free(clause_list);
341 clause_list = NULL;
342 CU_PASS("db_clause_list_free");
343 CU_PASS("db_clause_free");
344 }
345
test_class_db_configuration(void)346 void test_class_db_configuration(void) {
347 CU_ASSERT_PTR_NOT_NULL_FATAL((configuration = db_configuration_new()));
348 CU_ASSERT(!db_configuration_set_name(configuration, "name1"));
349 CU_ASSERT(!db_configuration_set_value(configuration, "value1"));
350 CU_ASSERT(!db_configuration_not_empty(configuration));
351 CU_ASSERT_PTR_NOT_NULL_FATAL(db_configuration_value(configuration));
352 CU_ASSERT(!strcmp(db_configuration_value(configuration), "value1"));
353
354 CU_ASSERT_PTR_NOT_NULL_FATAL((configuration2 = db_configuration_new()));
355 CU_ASSERT(!db_configuration_set_name(configuration2, "name2"));
356 CU_ASSERT(!db_configuration_set_value(configuration2, "value2"));
357 CU_ASSERT(!db_configuration_not_empty(configuration2));
358 CU_ASSERT_PTR_NOT_NULL_FATAL(db_configuration_value(configuration2));
359 CU_ASSERT(!strcmp(db_configuration_value(configuration2), "value2"));
360 }
361
test_class_db_configuration_list(void)362 void test_class_db_configuration_list(void) {
363 db_configuration_t* local_configuration = configuration;
364 db_configuration_t* local_configuration2 = configuration2;
365
366 CU_ASSERT_PTR_NOT_NULL_FATAL((configuration_list = db_configuration_list_new()));
367
368 CU_ASSERT_FATAL(!db_configuration_list_add(configuration_list, configuration));
369 configuration = NULL;
370 CU_ASSERT_FATAL(!db_configuration_list_add(configuration_list, configuration2));
371 configuration2 = NULL;
372
373 CU_ASSERT(db_configuration_list_find(configuration_list, "name1") == local_configuration);
374 CU_ASSERT(db_configuration_list_find(configuration_list, "name2") == local_configuration2);
375
376 db_configuration_list_free(configuration_list);
377 configuration_list = NULL;
378 CU_PASS("db_configuration_list_free");
379 CU_PASS("db_configuration_free");
380 }
381
test_class_db_connection(void)382 void test_class_db_connection(void) {
383 CU_ASSERT_PTR_NOT_NULL_FATAL((connection = db_connection_new()));
384
385 CU_ASSERT_FATAL(!db_connection_set_configuration_list(connection, (db_configuration_list_t*)&fake_pointer));
386
387 connection->backend = backend;
388 backend = NULL;
389
390 CU_ASSERT_FATAL(!db_connection_setup(connection));
391 CU_ASSERT(!db_connection_connect(connection));
392 CU_ASSERT(!db_connection_create(connection, (db_object_t*)&fake_pointer, (db_object_field_list_t*)&fake_pointer, (db_value_set_t*)&fake_pointer));
393 CU_ASSERT(db_connection_read(connection, (db_object_t*)&fake_pointer, (db_join_list_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer) == (db_result_list_t*)&fake_pointer);
394 CU_ASSERT(!db_connection_update(connection, (db_object_t*)&fake_pointer, (db_object_field_list_t*)&fake_pointer, (db_value_set_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer));
395 CU_ASSERT(!db_connection_delete(connection, (db_object_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer));
396 CU_ASSERT(!db_connection_count(connection, (db_object_t*)&fake_pointer, (db_join_list_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer, (size_t*)&fake_pointer));
397 }
398
test_class_db_object_field(void)399 void test_class_db_object_field(void) {
400 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
401 CU_ASSERT(!db_object_field_set_name(object_field, "field1"));
402 CU_ASSERT(!db_object_field_set_type(object_field, DB_TYPE_INT32));
403 CU_ASSERT(!db_object_field_not_empty(object_field));
404 CU_ASSERT_PTR_NOT_NULL_FATAL(db_object_field_name(object_field));
405 CU_ASSERT(!strcmp(db_object_field_name(object_field), "field1"));
406 CU_ASSERT(db_object_field_type(object_field) == DB_TYPE_INT32);
407
408 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field2 = db_object_field_new()));
409 CU_ASSERT(!db_object_field_set_name(object_field2, "field2"));
410 CU_ASSERT(!db_object_field_set_type(object_field2, DB_TYPE_ENUM));
411 CU_ASSERT(!db_object_field_set_enum_set(object_field2, (db_enum_t*)&fake_pointer));
412 CU_ASSERT(!db_object_field_not_empty(object_field2));
413 CU_ASSERT_PTR_NOT_NULL_FATAL(db_object_field_name(object_field2));
414 CU_ASSERT(!strcmp(db_object_field_name(object_field2), "field2"));
415 CU_ASSERT(db_object_field_type(object_field2) == DB_TYPE_ENUM);
416 }
417
test_class_db_object_field_list(void)418 void test_class_db_object_field_list(void) {
419 db_object_field_t* local_object_field = object_field;
420 db_object_field_t* local_object_field2 = object_field2;
421 const db_object_field_t* object_field_walk;
422
423 CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));
424
425 CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
426 object_field = NULL;
427 CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field2));
428 object_field2 = NULL;
429
430 CU_ASSERT((object_field_walk = db_object_field_list_begin(object_field_list)) == local_object_field);
431 CU_ASSERT(db_object_field_next(object_field_walk) == local_object_field2);
432 }
433
test_class_db_object(void)434 void test_class_db_object(void) {
435 db_object_field_list_t* local_object_field_list = object_field_list;
436
437 CU_ASSERT_PTR_NOT_NULL_FATAL((object = db_object_new()));
438
439 CU_ASSERT(!db_object_set_connection(object, connection));
440 CU_ASSERT(!db_object_set_table(object, "table"));
441 CU_ASSERT(!db_object_set_primary_key_name(object, "primary_key"));
442 CU_ASSERT(!db_object_set_object_field_list(object, object_field_list));
443 object_field_list = NULL;
444
445 CU_ASSERT(db_object_connection(object) == connection);
446 CU_ASSERT_PTR_NOT_NULL_FATAL(db_object_table(object));
447 CU_ASSERT(!strcmp(db_object_table(object), "table"));
448 CU_ASSERT(db_object_object_field_list(object) == local_object_field_list);
449
450 CU_ASSERT(!db_object_create(object, (db_object_field_list_t*)&fake_pointer, (db_value_set_t*)&fake_pointer));
451 CU_ASSERT(db_object_read(object, (db_join_list_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer) == (db_result_list_t*)&fake_pointer);
452 CU_ASSERT(!db_object_update(object, (db_object_field_list_t*)&fake_pointer, (db_value_set_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer));
453 CU_ASSERT(!db_object_delete(object, (db_clause_list_t*)&fake_pointer));
454 CU_ASSERT(!db_object_count(object, (db_join_list_t*)&fake_pointer, (db_clause_list_t*)&fake_pointer, (size_t*)&fake_pointer));
455
456 db_object_free(object);
457 object = NULL;
458 CU_PASS("db_object_free");
459 }
460
test_class_db_value_set(void)461 void test_class_db_value_set(void) {
462 CU_ASSERT_PTR_NOT_NULL_FATAL((value_set = db_value_set_new(2)));
463 CU_ASSERT(db_value_set_size(value_set) == 2);
464 CU_ASSERT_PTR_NOT_NULL(db_value_set_at(value_set, 0));
465 CU_ASSERT_PTR_NOT_NULL(db_value_set_at(value_set, 1));
466 CU_ASSERT_PTR_NULL(db_value_set_at(value_set, 2));
467 CU_ASSERT_PTR_NOT_NULL(db_value_set_get(value_set, 0));
468 CU_ASSERT_PTR_NOT_NULL(db_value_set_get(value_set, 1));
469 CU_ASSERT_PTR_NULL(db_value_set_get(value_set, 2));
470
471 CU_ASSERT_PTR_NOT_NULL_FATAL((value_set2 = db_value_set_new(6)));
472 CU_ASSERT(db_value_set_size(value_set2) == 6);
473 CU_ASSERT_PTR_NOT_NULL(db_value_set_at(value_set2, 0));
474 CU_ASSERT_PTR_NOT_NULL(db_value_set_at(value_set2, 1));
475 CU_ASSERT_PTR_NOT_NULL(db_value_set_at(value_set2, 2));
476 CU_ASSERT_PTR_NOT_NULL(db_value_set_at(value_set2, 3));
477 CU_ASSERT_PTR_NOT_NULL(db_value_set_at(value_set2, 4));
478 CU_ASSERT_PTR_NOT_NULL(db_value_set_at(value_set2, 5));
479 CU_ASSERT_PTR_NULL(db_value_set_at(value_set2, 6));
480 CU_ASSERT_PTR_NOT_NULL(db_value_set_get(value_set2, 0));
481 CU_ASSERT_PTR_NOT_NULL(db_value_set_get(value_set2, 1));
482 CU_ASSERT_PTR_NOT_NULL(db_value_set_get(value_set2, 2));
483 CU_ASSERT_PTR_NOT_NULL(db_value_set_get(value_set2, 3));
484 CU_ASSERT_PTR_NOT_NULL(db_value_set_get(value_set2, 4));
485 CU_ASSERT_PTR_NOT_NULL(db_value_set_get(value_set2, 5));
486 CU_ASSERT_PTR_NULL(db_value_set_get(value_set2, 6));
487 }
488
test_class_db_result(void)489 void test_class_db_result(void) {
490 db_value_set_t* local_value_set = value_set;
491 db_value_set_t* local_value_set2 = value_set2;
492
493 CU_ASSERT_PTR_NOT_NULL_FATAL((result = db_result_new()));
494 CU_ASSERT(!db_result_set_value_set(result, value_set));
495 value_set = NULL;
496 CU_ASSERT(db_result_value_set(result) == local_value_set);
497
498 CU_ASSERT_PTR_NOT_NULL_FATAL((result2 = db_result_new()));
499 CU_ASSERT(!db_result_set_value_set(result2, value_set2));
500 value_set2 = NULL;
501 CU_ASSERT(db_result_value_set(result2) == local_value_set2);
502 CU_ASSERT(!db_result_not_empty(result2));
503 }
504
505 static int __db_result_list_next_count = 0;
__db_result_list_next(void * data,int finish)506 db_result_t* __db_result_list_next(void* data, int finish) {
507 db_value_set_t* value_set;
508 db_result_t* result;
509
510 CU_ASSERT_FATAL(data == &fake_pointer);
511
512 if (finish) {
513 return NULL;
514 }
515
516 if (__db_result_list_next_count > 2) {
517 return NULL;
518 }
519
520 CU_ASSERT_PTR_NOT_NULL_FATAL((value_set = db_value_set_new(2)));
521 CU_ASSERT(db_value_set_size(value_set) == 2);
522 CU_ASSERT_PTR_NOT_NULL(db_value_set_at(value_set, 0));
523 CU_ASSERT_PTR_NOT_NULL(db_value_set_at(value_set, 1));
524 CU_ASSERT_PTR_NULL(db_value_set_at(value_set, 2));
525 CU_ASSERT_PTR_NOT_NULL(db_value_set_get(value_set, 0));
526 CU_ASSERT_PTR_NOT_NULL(db_value_set_get(value_set, 1));
527 CU_ASSERT_PTR_NULL(db_value_set_get(value_set, 2));
528
529 CU_ASSERT_PTR_NOT_NULL_FATAL((result = db_result_new()));
530 CU_ASSERT(!db_result_set_value_set(result, value_set));
531 CU_ASSERT(!db_result_not_empty(result));
532
533 __db_result_list_next_count++;
534
535 return result;
536 }
537
test_class_db_result_list(void)538 void test_class_db_result_list(void) {
539 db_result_t* local_result = result;
540 db_result_t* local_result2 = result2;
541
542 CU_ASSERT_PTR_NOT_NULL_FATAL((result_list = db_result_list_new()));
543
544 CU_ASSERT_FATAL(!db_result_list_add(result_list, result));
545 result = NULL;
546 CU_ASSERT_FATAL(!db_result_list_add(result_list, result2));
547 result2 = NULL;
548
549 CU_ASSERT(db_result_list_size(result_list) == 2);
550 CU_ASSERT(db_result_list_begin(result_list) == local_result);
551 CU_ASSERT(db_result_list_next(result_list) == local_result2);
552
553 db_result_list_free(result_list);
554 result_list = NULL;
555 CU_PASS("db_result_list_free");
556 CU_PASS("db_result_free");
557
558 CU_ASSERT_PTR_NOT_NULL_FATAL((result_list = db_result_list_new()));
559
560 CU_ASSERT_FATAL(!db_result_list_set_next(result_list, __db_result_list_next, &fake_pointer, 2));
561
562 CU_ASSERT(db_result_list_size(result_list) == 2);
563 CU_ASSERT_PTR_NOT_NULL(db_result_list_begin(result_list));
564 CU_ASSERT_PTR_NOT_NULL(db_result_list_next(result_list));
565
566 db_result_list_free(result_list);
567 result_list = NULL;
568 CU_PASS("db_result_list_free");
569 CU_PASS("db_result_free");
570 }
571
test_class_db_value(void)572 void test_class_db_value(void) {
573 char* text = NULL;
574 int ret;
575 db_type_int32_t int32;
576 db_type_uint32_t uint32;
577 db_type_int64_t int64;
578 db_type_uint64_t uint64;
579 CU_ASSERT_PTR_NOT_NULL_FATAL((value2 = db_value_new()));
580
581 CU_ASSERT_PTR_NOT_NULL_FATAL((value = db_value_new()));
582 CU_ASSERT(!db_value_from_text(value, "test"));
583 CU_ASSERT(db_value_type(value) == DB_TYPE_TEXT);
584 CU_ASSERT_PTR_NOT_NULL_FATAL(db_value_text(value));
585 CU_ASSERT(!strcmp(db_value_text(value), "test"));
586 CU_ASSERT(!db_value_to_text(value, &text));
587 CU_ASSERT_PTR_NOT_NULL(text);
588 free(text);
589 text = NULL;
590 CU_ASSERT(!db_value_not_empty(value));
591 CU_ASSERT(!db_value_copy(value2, value));
592 CU_ASSERT(db_value_type(value2) == DB_TYPE_TEXT);
593 CU_ASSERT_PTR_NOT_NULL_FATAL(db_value_text(value2));
594 CU_ASSERT(!strcmp(db_value_text(value2), "test"));
595 CU_ASSERT(!db_value_cmp(value, value2, &ret));
596 CU_ASSERT(!ret);
597 CU_ASSERT(!db_value_set_primary_key(value));
598
599 db_value_reset(value);
600 CU_PASS("db_value_reset");
601
602 CU_ASSERT(!db_value_from_int32(value, -12345));
603 CU_ASSERT(db_value_type(value) == DB_TYPE_INT32);
604 CU_ASSERT(!db_value_to_int32(value, &int32));
605 CU_ASSERT(int32 == -12345);
606 CU_ASSERT(!db_value_not_empty(value));
607 db_value_reset(value2);
608 CU_PASS("db_value_reset");
609 CU_ASSERT(!db_value_copy(value2, value));
610 CU_ASSERT(db_value_type(value2) == DB_TYPE_INT32);
611 CU_ASSERT(!db_value_to_int32(value2, &int32));
612 CU_ASSERT(int32 == -12345);
613 CU_ASSERT(!db_value_cmp(value, value2, &ret));
614 CU_ASSERT(!ret);
615 CU_ASSERT(!db_value_set_primary_key(value));
616
617 db_value_reset(value);
618 CU_PASS("db_value_reset");
619
620 CU_ASSERT(!db_value_from_uint32(value, 12345));
621 CU_ASSERT(db_value_type(value) == DB_TYPE_UINT32);
622 CU_ASSERT(!db_value_to_uint32(value, &uint32));
623 CU_ASSERT(uint32 == 12345);
624 CU_ASSERT(!db_value_not_empty(value));
625 db_value_reset(value2);
626 CU_PASS("db_value_reset");
627 CU_ASSERT(!db_value_copy(value2, value));
628 CU_ASSERT(db_value_type(value2) == DB_TYPE_UINT32);
629 CU_ASSERT(!db_value_to_uint32(value2, &uint32));
630 CU_ASSERT(uint32 == 12345);
631 CU_ASSERT(!db_value_cmp(value, value2, &ret));
632 CU_ASSERT(!ret);
633 CU_ASSERT(!db_value_set_primary_key(value));
634
635 db_value_reset(value);
636 CU_PASS("db_value_reset");
637
638 CU_ASSERT(!db_value_from_int64(value, -9223372036854775800));
639 CU_ASSERT(db_value_type(value) == DB_TYPE_INT64);
640 CU_ASSERT(!db_value_to_int64(value, &int64));
641 CU_ASSERT(int64 == -9223372036854775800);
642 CU_ASSERT(!db_value_not_empty(value));
643 db_value_reset(value2);
644 CU_PASS("db_value_reset");
645 CU_ASSERT(!db_value_copy(value2, value));
646 CU_ASSERT(db_value_type(value2) == DB_TYPE_INT64);
647 CU_ASSERT(!db_value_to_int64(value2, &int64));
648 CU_ASSERT(int64 == -9223372036854775800);
649 CU_ASSERT(!db_value_cmp(value, value2, &ret));
650 CU_ASSERT(!ret);
651 CU_ASSERT(!db_value_set_primary_key(value));
652
653 db_value_reset(value);
654 CU_PASS("db_value_reset");
655
656
657 CU_ASSERT(!db_value_from_uint64(value, 17446744073709551615UL));
658 CU_ASSERT(db_value_type(value) == DB_TYPE_UINT64);
659 CU_ASSERT(!db_value_to_uint64(value, &uint64));
660 CU_ASSERT(uint64 == 17446744073709551615UL);
661 CU_ASSERT(!db_value_not_empty(value));
662 db_value_reset(value2);
663 CU_PASS("db_value_reset");
664 CU_ASSERT(!db_value_copy(value2, value));
665 CU_ASSERT(db_value_type(value2) == DB_TYPE_UINT64);
666 CU_ASSERT(!db_value_to_uint64(value2, &uint64));
667 CU_ASSERT(uint64 == 17446744073709551615UL);
668 CU_ASSERT(!db_value_cmp(value, value2, &ret));
669 CU_ASSERT(!ret);
670 CU_ASSERT(!db_value_set_primary_key(value));
671
672 db_value_reset(value);
673 CU_PASS("db_value_reset");
674
675 CU_ASSERT(!db_value_from_enum_value(value, 2, enum_set));
676 CU_ASSERT(db_value_type(value) == DB_TYPE_ENUM);
677 CU_ASSERT(!db_value_enum_value(value, &ret));
678 CU_ASSERT(ret == 2);
679 CU_ASSERT(!db_value_to_enum_value(value, &ret, enum_set));
680 CU_ASSERT(ret == 2);
681 CU_ASSERT(!db_value_not_empty(value));
682 db_value_reset(value2);
683 CU_PASS("db_value_reset");
684 CU_ASSERT(!db_value_copy(value2, value));
685 CU_ASSERT(db_value_type(value2) == DB_TYPE_ENUM);
686 CU_ASSERT(!db_value_enum_value(value2, &ret));
687 CU_ASSERT(ret == 2);
688 CU_ASSERT(!db_value_to_enum_value(value2, &ret, enum_set));
689 CU_ASSERT(ret == 2);
690 CU_ASSERT(!db_value_cmp(value, value2, &ret));
691 CU_ASSERT(!ret);
692 CU_ASSERT(db_value_set_primary_key(value));
693
694 db_value_reset(value);
695 CU_PASS("db_value_reset");
696
697 db_value_free(value);
698 value = NULL;
699 CU_PASS("db_value_free");
700 db_value_free(value2);
701 value2 = NULL;
702 CU_PASS("db_value_free");
703 }
704
test_class_end(void)705 void test_class_end(void) {
706 db_result_free(result);
707 result = NULL;
708 db_result_free(result2);
709 result2 = NULL;
710 CU_PASS("db_result_free");
711
712 db_value_set_free(value_set);
713 value_set = NULL;
714 db_value_set_free(value_set2);
715 value_set2 = NULL;
716 CU_PASS("db_value_set_free");
717
718 db_object_field_list_free(object_field_list);
719 object_field_list = NULL;
720 CU_PASS("db_object_field_list_free");
721 CU_PASS("db_object_field_free");
722
723 db_connection_free(connection);
724 connection = NULL;
725 CU_PASS("db_connection_free");
726
727 db_backend_free(backend);
728 backend = NULL;
729 CU_PASS("db_backend_handle_free");
730 CU_PASS("db_backend_free");
731 }
732