OpenDNSSEC-enforcer  2.0.2
test_database_operations.c
Go to the documentation of this file.
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 "config.h"
31 
32 #include "../db_configuration.h"
33 #include "../db_connection.h"
34 #include "../db_object.h"
35 
36 #include "CUnit/Basic.h"
37 #include <string.h>
38 
39 typedef struct {
42  char* name;
43 } test_t;
44 
45 typedef struct {
49 } test_list_t;
50 
51 static db_configuration_list_t* configuration_list = NULL;
52 static db_configuration_t* configuration = NULL;
53 static db_connection_t* connection = NULL;
54 static test_t* test = NULL;
55 static test_list_t* test_list = NULL;
56 static db_value_t object2_id, object3_id;
57 
59  db_object_field_list_t* object_field_list;
60  db_object_field_t* object_field;
61  db_object_t* object;
62 
63  CU_ASSERT_PTR_NOT_NULL_FATAL((object = db_object_new()));
64 
65  CU_ASSERT_FATAL(!db_object_set_connection(object, connection));
66  CU_ASSERT_FATAL(!db_object_set_table(object, "test"));
67  CU_ASSERT_FATAL(!db_object_set_primary_key_name(object, "id"));
68 
69  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));
70 
71  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
72  CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "id"));
73  CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_PRIMARY_KEY));
74  CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
75 
76  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
77  CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "name"));
78  CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_TEXT));
79  CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
80 
81  CU_ASSERT_FATAL(!db_object_set_object_field_list(object, object_field_list));
82 
83  return object;
84 }
85 
86 test_t* test_new(const db_connection_t* connection) {
87  test_t* test =
88  (test_t*)calloc(1, sizeof(test_t));
89 
90  if (test) {
91  CU_ASSERT_PTR_NOT_NULL_FATAL((test->dbo = __test_new_object(connection)));
92  CU_ASSERT_PTR_NOT_NULL_FATAL((test->id = db_value_new()));
93  }
94 
95  return test;
96 }
97 
98 void test_free(test_t* test) {
99  if (test) {
100  if (test->dbo) {
101  db_object_free(test->dbo);
102  }
103  if (test->id) {
104  db_value_free(test->id);
105  }
106  if (test->name) {
107  free(test->name);
108  }
109  free(test);
110  }
111 }
112 
113 const db_value_t* test_id(const test_t* test) {
114  CU_ASSERT_PTR_NOT_NULL_FATAL(test);
115 
116  return test->id;
117 }
118 
119 const char* test_name(const test_t* test) {
120  CU_ASSERT_PTR_NOT_NULL_FATAL(test);
121 
122  return test->name;
123 }
124 
125 int test_set_name(test_t* test, const char *name) {
126  CU_ASSERT_PTR_NOT_NULL_FATAL(test);
127  CU_ASSERT_PTR_NOT_NULL_FATAL(name);
128 
129  if (test->name) {
130  free(test->name);
131  }
132  test->name = strdup(name);
133  CU_ASSERT_PTR_NOT_NULL_FATAL(test->name);
134  return 0;
135 }
136 
137 int test_from_result(test_t* test, const db_result_t* result) {
138  const db_value_set_t* value_set;
139 
140  CU_ASSERT_PTR_NOT_NULL_FATAL(test);
141  CU_ASSERT_PTR_NOT_NULL_FATAL(result);
142 
143  db_value_reset(test->id);
144  if (test->name) {
145  free(test->name);
146  }
147  test->name = NULL;
148 
149  value_set = db_result_value_set(result);
150 
151  CU_ASSERT_PTR_NOT_NULL_FATAL(value_set);
152  CU_ASSERT_FATAL(db_value_set_size(value_set) == 2);
153  CU_ASSERT_FATAL(!db_value_copy(test->id, db_value_set_at(value_set, 0)));
154  CU_ASSERT_FATAL(!db_value_to_text(db_value_set_at(value_set, 1), &(test->name)));
155  return 0;
156 }
157 
158 int test_get_by_name(test_t* test, const char* name) {
159  db_clause_list_t* clause_list;
160  db_clause_t* clause;
161  db_result_list_t* result_list;
162  const db_result_t* result;
163  int ret;
164 
165  CU_ASSERT_PTR_NOT_NULL_FATAL(test);
166  CU_ASSERT_PTR_NOT_NULL_FATAL(name);
167 
168  CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
169  CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
170  CU_ASSERT_FATAL(!db_clause_set_field(clause, "name"));
171  CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
172  CU_ASSERT_FATAL(!db_value_from_text(db_clause_get_value(clause), name));
173  CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
174  clause = NULL;
175 
176  ret = 1;
177  result_list = db_object_read(test->dbo, NULL, clause_list);
178  if (result_list) {
179  result = db_result_list_next(result_list);
180  if (result) {
181  test_from_result(test, result);
182  ret = 0;
183  }
184  CU_ASSERT_PTR_NULL((result = db_result_list_next(result_list)));
185  if (result) {
186  db_result_list_free(result_list);
187  db_clause_list_free(clause_list);
188  return 1;
189  }
190  }
191 
192  db_result_list_free(result_list);
193  db_clause_list_free(clause_list);
194  db_clause_free(clause);
195  return ret;
196 }
197 
198 int test_get_by_id(test_t* test, const db_value_t* id) {
199  db_clause_list_t* clause_list;
200  db_clause_t* clause;
201  db_result_list_t* result_list;
202  const db_result_t* result;
203  int ret;
204 
205  CU_ASSERT_PTR_NOT_NULL_FATAL(test);
206  CU_ASSERT_PTR_NOT_NULL_FATAL(id);
207 
208  CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
209  CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
210  CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
211  CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
212  CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), id));
213  CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
214  clause = NULL;
215 
216  ret = 1;
217  result_list = db_object_read(test->dbo, NULL, clause_list);
218  if (result_list) {
219  result = db_result_list_next(result_list);
220  if (result) {
221  test_from_result(test, result);
222  ret = 0;
223  }
224  CU_ASSERT_PTR_NULL((result = db_result_list_next(result_list)));
225  if (result) {
226  db_result_list_free(result_list);
227  db_clause_list_free(clause_list);
228  return 1;
229  }
230  }
231 
232  db_result_list_free(result_list);
233  db_clause_list_free(clause_list);
234  db_clause_free(clause);
235  return ret;
236 }
237 
238 int test_create(test_t* test) {
239  db_object_field_list_t* object_field_list;
240  db_object_field_t* object_field;
241  db_value_set_t* value_set;
242  db_value_t* value;
243  int ret = 0;
244 
245  CU_ASSERT_PTR_NOT_NULL_FATAL(test);
246  CU_ASSERT_FATAL(db_value_not_empty(test->id));
247  CU_ASSERT_PTR_NOT_NULL_FATAL(test->name);
248 
249  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));
250  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
251  CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "name"));
252  CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_TEXT));
253  CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
254  object_field = NULL;
255 
256  CU_ASSERT_PTR_NOT_NULL_FATAL((value_set = db_value_set_new(1)));
257  CU_ASSERT_PTR_NOT_NULL_FATAL((value = db_value_set_get(value_set, 0)));
258  CU_ASSERT_FATAL(!db_value_from_text(value, test->name));
259 
260  if (db_object_create(test->dbo, object_field_list, value_set)) {
261  ret = 1;
262  }
263 
264  db_value_set_free(value_set);
265  db_object_field_free(object_field);
266  db_object_field_list_free(object_field_list);
267  CU_ASSERT(!ret);
268  return ret;
269 }
270 
271 int test_update(test_t* test) {
272  db_clause_list_t* clause_list;
273  db_clause_t* clause;
274  db_object_field_list_t* object_field_list;
275  db_object_field_t* object_field;
276  db_value_set_t* value_set;
277  db_value_t* value;
278  int ret = 0;
279 
280  CU_ASSERT_PTR_NOT_NULL_FATAL(test);
281  CU_ASSERT_FATAL(!db_value_not_empty(test->id));
282  CU_ASSERT_PTR_NOT_NULL_FATAL(test->name);
283 
284  CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
285  CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
286  CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
287  CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
288  CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), test->id));
289  CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
290  clause = NULL;
291 
292  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));
293  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
294  CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "name"));
295  CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_TEXT));
296  CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
297  object_field = NULL;
298 
299  CU_ASSERT_PTR_NOT_NULL_FATAL((value_set = db_value_set_new(1)));
300  CU_ASSERT_PTR_NOT_NULL_FATAL((value = db_value_set_get(value_set, 0)));
301  CU_ASSERT_FATAL(!db_value_from_text(value, test->name));
302 
303  if (db_object_update(test->dbo, object_field_list, value_set, clause_list)) {
304  ret = 1;
305  }
306 
307  db_clause_list_free(clause_list);
308  db_clause_free(clause);
309  db_value_set_free(value_set);
310  db_object_field_free(object_field);
311  db_object_field_list_free(object_field_list);
312  CU_ASSERT(!ret);
313  return ret;
314 }
315 
316 int test_delete(test_t* test) {
317  db_clause_list_t* clause_list;
318  db_clause_t* clause;
319  int ret = 0;
320 
321  CU_ASSERT_PTR_NOT_NULL_FATAL(test);
322  CU_ASSERT_FATAL(!db_value_not_empty(test->id));
323 
324  CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
325  CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
326  CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
327  CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
328  CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), test->id));
329  CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
330  clause = NULL;
331 
332  if (db_object_delete(test->dbo, clause_list)) {
333  ret = 1;
334  }
335 
336  db_clause_list_free(clause_list);
337  db_clause_free(clause);
338  CU_ASSERT(!ret);
339  return ret;
340 }
341 
342 size_t test_count_by_name(test_t* test, const char* name) {
343  db_clause_list_t* clause_list;
344  db_clause_t* clause;
345  size_t ret = 0;
346 
347  CU_ASSERT_PTR_NOT_NULL_FATAL(test);
348  CU_ASSERT_PTR_NOT_NULL_FATAL(name);
349 
350  CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
351  CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
352  CU_ASSERT_FATAL(!db_clause_set_field(clause, "name"));
353  CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
354  CU_ASSERT_FATAL(!db_value_from_text(db_clause_get_value(clause), name));
355  CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
356  clause = NULL;
357 
358  CU_ASSERT(!db_object_count(test->dbo, NULL, clause_list, &ret));
359 
360  db_clause_list_free(clause_list);
361  db_clause_free(clause);
362  return ret;
363 }
364 
365 size_t test_count_by_id(test_t* test, const db_value_t* id) {
366  db_clause_list_t* clause_list;
367  db_clause_t* clause;
368  size_t ret = 0;
369 
370  CU_ASSERT_PTR_NOT_NULL_FATAL(test);
371  CU_ASSERT_PTR_NOT_NULL_FATAL(id);
372 
373  CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
374  CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
375  CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
376  CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
377  CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), id));
378  CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
379  clause = NULL;
380 
381  CU_ASSERT(!db_object_count(test->dbo, NULL, clause_list, &ret));
382 
383  db_clause_list_free(clause_list);
384  db_clause_free(clause);
385  return ret;
386 }
387 
389  test_list_t* test_list =
390  (test_list_t*)calloc(1, sizeof(test_list_t));
391 
392  if (test_list) {
393  CU_ASSERT_PTR_NOT_NULL_FATAL((test_list->dbo = __test_new_object(connection)));
394  }
395 
396  return test_list;
397 }
398 
399 void test_list_free(test_list_t* test_list) {
400  if (test_list) {
401  if (test_list->dbo) {
402  db_object_free(test_list->dbo);
403  }
404  if (test_list->result_list) {
405  db_result_list_free(test_list->result_list);
406  }
407  if (test_list->test) {
408  test_free(test_list->test);
409  }
410  free(test_list);
411  }
412 }
413 
414 int test_list_get(test_list_t* test_list) {
415  CU_ASSERT_PTR_NOT_NULL_FATAL(test_list);
416  CU_ASSERT_PTR_NOT_NULL_FATAL(test_list->dbo);
417 
418  if (test_list->result_list) {
419  db_result_list_free(test_list->result_list);
420  }
421  CU_ASSERT_PTR_NOT_NULL((test_list->result_list = db_object_read(test_list->dbo, NULL, NULL)));
422  if (!test_list->result_list) {
423  return 1;
424  }
425  return 0;
426 }
427 
428 const test_t* test_list_begin(test_list_t* test_list) {
429  const db_result_t* result;
430 
431  CU_ASSERT_PTR_NOT_NULL_FATAL(test_list);
432  CU_ASSERT_PTR_NOT_NULL_FATAL(test_list->result_list);
433 
434  result = db_result_list_next(test_list->result_list);
435  if (!result) {
436  return NULL;
437  }
438  if (!test_list->test) {
439  CU_ASSERT_PTR_NOT_NULL_FATAL((test_list->test = test_new(db_object_connection(test_list->dbo))));
440  }
441  if (test_from_result(test_list->test, result)) {
442  return NULL;
443  }
444  return test_list->test;
445 }
446 
447 const test_t* test_list_next(test_list_t* test_list) {
448  const db_result_t* result;
449 
450  CU_ASSERT_PTR_NOT_NULL_FATAL(test_list);
451 
452  result = db_result_list_next(test_list->result_list);
453  if (!result) {
454  return NULL;
455  }
456  if (!test_list->test) {
457  CU_ASSERT_PTR_NOT_NULL_FATAL((test_list->test = test_new(db_object_connection(test_list->dbo))));
458  }
459  if (test_from_result(test_list->test, result)) {
460  return NULL;
461  }
462  return test_list->test;
463 }
464 
465 typedef struct {
469  char* name;
470 } test2_t;
471 
472 static test2_t* test2 = NULL;
473 static test2_t* test2_2 = NULL;
474 
476  db_object_field_list_t* object_field_list;
477  db_object_field_t* object_field;
478  db_object_t* object;
479 
480  CU_ASSERT_PTR_NOT_NULL_FATAL((object = db_object_new()));
481 
482  CU_ASSERT_FATAL(!db_object_set_connection(object, connection));
483  CU_ASSERT_FATAL(!db_object_set_table(object, "test2"));
484  CU_ASSERT_FATAL(!db_object_set_primary_key_name(object, "id"));
485 
486  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));
487 
488  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
489  CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "id"));
490  CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_PRIMARY_KEY));
491  CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
492 
493  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
494  CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "rev"));
495  CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_REVISION));
496  CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
497 
498  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
499  CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "name"));
500  CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_TEXT));
501  CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
502 
503  CU_ASSERT_FATAL(!db_object_set_object_field_list(object, object_field_list));
504 
505  return object;
506 }
507 
508 test2_t* test2_new(const db_connection_t* connection) {
509  test2_t* test2 =
510  (test2_t*)calloc(1, sizeof(test2_t));
511 
512  if (test2) {
513  CU_ASSERT_PTR_NOT_NULL_FATAL((test2->dbo = __test2_new_object(connection)));
514  CU_ASSERT_PTR_NOT_NULL_FATAL((test2->id = db_value_new()));
515  CU_ASSERT_PTR_NOT_NULL_FATAL((test2->rev = db_value_new()));
516  }
517 
518  return test2;
519 }
520 
521 void test2_free(test2_t* test2) {
522  if (test2) {
523  if (test2->dbo) {
524  db_object_free(test2->dbo);
525  }
526  if (test2->id) {
527  db_value_free(test2->id);
528  }
529  if (test2->rev) {
530  db_value_free(test2->rev);
531  }
532  if (test2->name) {
533  free(test2->name);
534  }
535  free(test2);
536  }
537 }
538 
539 const db_value_t* test2_id(const test2_t* test2) {
540  CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
541 
542  return test2->id;
543 }
544 
545 const char* test2_name(const test2_t* test2) {
546  CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
547 
548  return test2->name;
549 }
550 
551 int test2_set_name(test2_t* test2, const char *name) {
552  CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
553  CU_ASSERT_PTR_NOT_NULL_FATAL(name);
554 
555  if (test2->name) {
556  free(test2->name);
557  }
558  test2->name = strdup(name);
559  CU_ASSERT_PTR_NOT_NULL_FATAL(test2->name);
560  return 0;
561 }
562 
563 int test2_from_result(test2_t* test2, const db_result_t* result) {
564  const db_value_set_t* value_set;
565 
566  CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
567  CU_ASSERT_PTR_NOT_NULL_FATAL(result);
568 
569  db_value_reset(test2->id);
570  db_value_reset(test2->rev);
571  if (test2->name) {
572  free(test2->name);
573  }
574  test2->name = NULL;
575 
576  value_set = db_result_value_set(result);
577 
578  CU_ASSERT_PTR_NOT_NULL_FATAL(value_set);
579  CU_ASSERT_FATAL(db_value_set_size(value_set) == 3);
580  CU_ASSERT_FATAL(!db_value_copy(test2->id, db_value_set_at(value_set, 0)));
581  CU_ASSERT_FATAL(!db_value_copy(test2->rev, db_value_set_at(value_set, 1)));
582  CU_ASSERT_FATAL(!db_value_to_text(db_value_set_at(value_set, 2), &(test2->name)));
583  return 0;
584 }
585 
586 int test2_get_by_name(test2_t* test2, const char* name) {
587  db_clause_list_t* clause_list;
588  db_clause_t* clause;
589  db_result_list_t* result_list;
590  const db_result_t* result;
591  int ret;
592 
593  CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
594  CU_ASSERT_PTR_NOT_NULL_FATAL(name);
595 
596  CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
597  CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
598  CU_ASSERT_FATAL(!db_clause_set_field(clause, "name"));
599  CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
600  CU_ASSERT_FATAL(!db_value_from_text(db_clause_get_value(clause), name));
601  CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
602  clause = NULL;
603 
604  ret = 1;
605  result_list = db_object_read(test2->dbo, NULL, clause_list);
606  if (result_list) {
607  result = db_result_list_next(result_list);
608  if (result) {
609  test2_from_result(test2, result);
610  ret = 0;
611  }
612  CU_ASSERT_PTR_NULL((result = db_result_list_next(result_list)));
613  if (result) {
614  db_result_list_free(result_list);
615  db_clause_list_free(clause_list);
616  return 1;
617  }
618  }
619 
620  db_result_list_free(result_list);
621  db_clause_list_free(clause_list);
622  db_clause_free(clause);
623  return ret;
624 }
625 
626 int test2_get_by_id(test2_t* test2, const db_value_t* id) {
627  db_clause_list_t* clause_list;
628  db_clause_t* clause;
629  db_result_list_t* result_list;
630  const db_result_t* result;
631  int ret;
632 
633  CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
634  CU_ASSERT_PTR_NOT_NULL_FATAL(id);
635 
636  CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
637  CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
638  CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
639  CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
640  CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), id));
641  CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
642  clause = NULL;
643 
644  ret = 1;
645  result_list = db_object_read(test2->dbo, NULL, clause_list);
646  if (result_list) {
647  result = db_result_list_next(result_list);
648  if (result) {
649  test2_from_result(test2, result);
650  ret = 0;
651  }
652  CU_ASSERT_PTR_NULL((result = db_result_list_next(result_list)));
653  if (result) {
654  db_result_list_free(result_list);
655  db_clause_list_free(clause_list);
656  return 1;
657  }
658  }
659 
660  db_result_list_free(result_list);
661  db_clause_list_free(clause_list);
662  db_clause_free(clause);
663  return ret;
664 }
665 
666 int test2_create(test2_t* test2) {
667  db_object_field_list_t* object_field_list;
668  db_object_field_t* object_field;
669  db_value_set_t* value_set;
670  db_value_t* value;
671  int ret = 0;
672 
673  CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
674  CU_ASSERT_FATAL(db_value_not_empty(test2->id));
675  CU_ASSERT_FATAL(db_value_not_empty(test2->rev));
676  CU_ASSERT_PTR_NOT_NULL_FATAL(test2->name);
677 
678  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));
679  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
680  CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "name"));
681  CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_TEXT));
682  CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
683  object_field = NULL;
684 
685  CU_ASSERT_PTR_NOT_NULL_FATAL((value_set = db_value_set_new(1)));
686  CU_ASSERT_PTR_NOT_NULL_FATAL((value = db_value_set_get(value_set, 0)));
687  CU_ASSERT_FATAL(!db_value_from_text(value, test2->name));
688 
689  if (db_object_create(test2->dbo, object_field_list, value_set)) {
690  ret = 1;
691  }
692 
693  db_value_set_free(value_set);
694  db_object_field_free(object_field);
695  db_object_field_list_free(object_field_list);
696  CU_ASSERT(!ret);
697  return ret;
698 }
699 
700 int test2_update(test2_t* test2) {
701  db_clause_list_t* clause_list;
702  db_clause_t* clause;
703  db_object_field_list_t* object_field_list;
704  db_object_field_t* object_field;
705  db_value_set_t* value_set;
706  db_value_t* value;
707  int ret = 0;
708 
709  CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
710  CU_ASSERT_FATAL(!db_value_not_empty(test2->id));
711  CU_ASSERT_FATAL(!db_value_not_empty(test2->rev));
712  CU_ASSERT_PTR_NOT_NULL_FATAL(test2->name);
713 
714  CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
715  CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
716  CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
717  CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
718  CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), test2->id));
719  CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
720  clause = NULL;
721  CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
722  CU_ASSERT_FATAL(!db_clause_set_field(clause, "rev"));
723  CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
724  CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), test2->rev));
725  CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
726  clause = NULL;
727 
728  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field_list = db_object_field_list_new()));
729  CU_ASSERT_PTR_NOT_NULL_FATAL((object_field = db_object_field_new()));
730  CU_ASSERT_FATAL(!db_object_field_set_name(object_field, "name"));
731  CU_ASSERT_FATAL(!db_object_field_set_type(object_field, DB_TYPE_TEXT));
732  CU_ASSERT_FATAL(!db_object_field_list_add(object_field_list, object_field));
733  object_field = NULL;
734 
735  CU_ASSERT_PTR_NOT_NULL_FATAL((value_set = db_value_set_new(1)));
736  CU_ASSERT_PTR_NOT_NULL_FATAL((value = db_value_set_get(value_set, 0)));
737  CU_ASSERT_FATAL(!db_value_from_text(value, test2->name));
738 
739  if (db_object_update(test2->dbo, object_field_list, value_set, clause_list)) {
740  ret = 1;
741  }
742 
743  db_clause_list_free(clause_list);
744  db_clause_free(clause);
745  db_value_set_free(value_set);
746  db_object_field_free(object_field);
747  db_object_field_list_free(object_field_list);
748  return ret;
749 }
750 
751 int test2_delete(test2_t* test2) {
752  db_clause_list_t* clause_list;
753  db_clause_t* clause;
754  int ret = 0;
755 
756  CU_ASSERT_PTR_NOT_NULL_FATAL(test2);
757  CU_ASSERT_FATAL(!db_value_not_empty(test2->id));
758  CU_ASSERT_FATAL(!db_value_not_empty(test2->rev));
759 
760  CU_ASSERT_PTR_NOT_NULL_FATAL((clause_list = db_clause_list_new()));
761  CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
762  CU_ASSERT_FATAL(!db_clause_set_field(clause, "id"));
763  CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
764  CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), test2->id));
765  CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
766  clause = NULL;
767  CU_ASSERT_PTR_NOT_NULL_FATAL((clause = db_clause_new()));
768  CU_ASSERT_FATAL(!db_clause_set_field(clause, "rev"));
769  CU_ASSERT_FATAL(!db_clause_set_type(clause, DB_CLAUSE_EQUAL));
770  CU_ASSERT_FATAL(!db_value_copy(db_clause_get_value(clause), test2->rev));
771  CU_ASSERT_FATAL(!db_clause_list_add(clause_list, clause));
772  clause = NULL;
773 
774  if (db_object_delete(test2->dbo, clause_list)) {
775  ret = 1;
776  }
777 
778  db_clause_list_free(clause_list);
779  db_clause_free(clause);
780  CU_ASSERT(!ret);
781  return ret;
782 }
783 
784 #if defined(ENFORCER_DATABASE_SQLITE3)
785 int init_suite_database_operations_sqlite(void) {
786  if (configuration_list) {
787  return 1;
788  }
789  if (configuration) {
790  return 1;
791  }
792  if (connection) {
793  return 1;
794  }
795  if (test) {
796  return 1;
797  }
798  if (test2) {
799  return 1;
800  }
801  if (test2_2) {
802  return 1;
803  }
804 
805  /*
806  * Setup the configuration for the connection
807  */
808  if (!(configuration_list = db_configuration_list_new())) {
809  return 1;
810  }
811  if (!(configuration = db_configuration_new())
812  || db_configuration_set_name(configuration, "backend")
813  || db_configuration_set_value(configuration, "sqlite")
814  || db_configuration_list_add(configuration_list, configuration))
815  {
816  db_configuration_free(configuration);
817  configuration = NULL;
818  db_configuration_list_free(configuration_list);
819  configuration_list = NULL;
820  return 1;
821  }
822  configuration = NULL;
823  if (!(configuration = db_configuration_new())
824  || db_configuration_set_name(configuration, "file")
825  || db_configuration_set_value(configuration, "test.db")
826  || db_configuration_list_add(configuration_list, configuration))
827  {
828  db_configuration_free(configuration);
829  configuration = NULL;
830  db_configuration_list_free(configuration_list);
831  configuration_list = NULL;
832  return 1;
833  }
834  configuration = NULL;
835 
836  /*
837  * Connect to the database
838  */
839  if (!(connection = db_connection_new())
840  || db_connection_set_configuration_list(connection, configuration_list))
841  {
842  db_connection_free(connection);
843  connection = NULL;
844  db_configuration_list_free(configuration_list);
845  configuration_list = NULL;
846  return 1;
847  }
848  configuration_list = NULL;
849 
850  if (db_connection_setup(connection)
851  || db_connection_connect(connection))
852  {
853  db_connection_free(connection);
854  connection = NULL;
855  return 1;
856  }
857 
858  return 0;
859 }
860 #endif
861 
862 #if defined(ENFORCER_DATABASE_MYSQL)
864  if (configuration_list) {
865  return 1;
866  }
867  if (configuration) {
868  return 1;
869  }
870  if (connection) {
871  return 1;
872  }
873  if (test) {
874  return 1;
875  }
876  if (test2) {
877  return 1;
878  }
879  if (test2_2) {
880  return 1;
881  }
882 
883  /*
884  * Setup the configuration for the connection
885  */
886  if (!(configuration_list = db_configuration_list_new())) {
887  return 1;
888  }
889  if (!(configuration = db_configuration_new())
890  || db_configuration_set_name(configuration, "backend")
891  || db_configuration_set_value(configuration, "mysql")
892  || db_configuration_list_add(configuration_list, configuration))
893  {
894  db_configuration_free(configuration);
895  configuration = NULL;
896  db_configuration_list_free(configuration_list);
897  configuration_list = NULL;
898  return 1;
899  }
900  configuration = NULL;
901  if (!(configuration = db_configuration_new())
902  || db_configuration_set_name(configuration, "host")
903  || db_configuration_set_value(configuration, ENFORCER_DB_HOST)
904  || db_configuration_list_add(configuration_list, configuration))
905  {
906  db_configuration_free(configuration);
907  configuration = NULL;
908  db_configuration_list_free(configuration_list);
909  configuration_list = NULL;
910  return 1;
911  }
912  configuration = NULL;
913  if (!(configuration = db_configuration_new())
914  || db_configuration_set_name(configuration, "port")
915  || db_configuration_set_value(configuration, ENFORCER_DB_PORT_TEXT)
916  || db_configuration_list_add(configuration_list, configuration))
917  {
918  db_configuration_free(configuration);
919  configuration = NULL;
920  db_configuration_list_free(configuration_list);
921  configuration_list = NULL;
922  return 1;
923  }
924  configuration = NULL;
925  if (!(configuration = db_configuration_new())
926  || db_configuration_set_name(configuration, "user")
927  || db_configuration_set_value(configuration, ENFORCER_DB_USERNAME)
928  || db_configuration_list_add(configuration_list, configuration))
929  {
930  db_configuration_free(configuration);
931  configuration = NULL;
932  db_configuration_list_free(configuration_list);
933  configuration_list = NULL;
934  return 1;
935  }
936  configuration = NULL;
937  if (!(configuration = db_configuration_new())
938  || db_configuration_set_name(configuration, "pass")
939  || db_configuration_set_value(configuration, ENFORCER_DB_PASSWORD)
940  || db_configuration_list_add(configuration_list, configuration))
941  {
942  db_configuration_free(configuration);
943  configuration = NULL;
944  db_configuration_list_free(configuration_list);
945  configuration_list = NULL;
946  return 1;
947  }
948  configuration = NULL;
949  if (!(configuration = db_configuration_new())
950  || db_configuration_set_name(configuration, "db")
951  || db_configuration_set_value(configuration, ENFORCER_DB_DATABASE)
952  || db_configuration_list_add(configuration_list, configuration))
953  {
954  db_configuration_free(configuration);
955  configuration = NULL;
956  db_configuration_list_free(configuration_list);
957  configuration_list = NULL;
958  return 1;
959  }
960  configuration = NULL;
961 
962  /*
963  * Connect to the database
964  */
965  if (!(connection = db_connection_new())
966  || db_connection_set_configuration_list(connection, configuration_list))
967  {
968  db_connection_free(connection);
969  connection = NULL;
970  db_configuration_list_free(configuration_list);
971  configuration_list = NULL;
972  return 1;
973  }
974  configuration_list = NULL;
975 
976  if (db_connection_setup(connection)
977  || db_connection_connect(connection))
978  {
979  db_connection_free(connection);
980  connection = NULL;
981  return 1;
982  }
983 
984  return 0;
985 }
986 #endif
987 
989  test_free(test);
990  test = NULL;
991  test_list_free(test_list);
992  test_list = NULL;
993  test2_free(test2);
994  test2 = NULL;
995  test2_free(test2_2);
996  test2_2 = NULL;
997  db_connection_free(connection);
998  connection = NULL;
999  db_configuration_free(configuration);
1000  configuration = NULL;
1001  db_configuration_list_free(configuration_list);
1002  configuration_list = NULL;
1003  db_value_reset(&object2_id);
1004  db_value_reset(&object3_id);
1005  return 0;
1006 }
1007 
1008 void __check_id(const db_value_t* id, int id_int, const char* id_text) {
1009  db_type_int32_t int32;
1010  db_type_uint32_t uint32;
1011  db_type_int64_t int64;
1012  db_type_uint64_t uint64;
1013  const char* text;
1014 
1015  CU_ASSERT_PTR_NOT_NULL(id);
1016  switch (db_value_type(id)) {
1017  case DB_TYPE_INT32:
1018  CU_ASSERT(!db_value_to_int32(id, &int32));
1019  CU_ASSERT(int32 == (db_type_int32_t)id_int);
1020  break;
1021 
1022  case DB_TYPE_UINT32:
1023  CU_ASSERT(!db_value_to_uint32(id, &uint32));
1024  CU_ASSERT(uint32 == (db_type_uint32_t)id_int);
1025  break;
1026 
1027  case DB_TYPE_INT64:
1028  CU_ASSERT(!db_value_to_int64(id, &int64));
1029  CU_ASSERT(int64 == (db_type_int64_t)id_int);
1030  break;
1031 
1032  case DB_TYPE_UINT64:
1033  CU_ASSERT(!db_value_to_uint64(id, &uint64));
1034  CU_ASSERT(uint64 == (db_type_uint64_t)id_int);
1035  break;
1036 
1037  case DB_TYPE_TEXT:
1038  CU_ASSERT_PTR_NOT_NULL_FATAL((text = db_value_text(id)));
1039  CU_ASSERT(!strcmp(text, id_text));
1040  break;
1041 
1042  default:
1043  CU_FAIL("db_value_type(id)");
1044  }
1045 }
1046 
1048  CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1049  CU_ASSERT_FATAL(!test_get_by_name(test, "test"));
1050  __check_id(test_id(test), 1, "1");
1051  CU_ASSERT_PTR_NOT_NULL_FATAL(test_name(test));
1052  CU_ASSERT(!strcmp(test_name(test), "test"));
1053 
1054  test_free(test);
1055  test = NULL;
1056  CU_PASS("test_free");
1057 }
1058 
1060  CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1061  CU_ASSERT_FATAL(!test_set_name(test, "name 2"));
1062  CU_ASSERT(!strcmp(test_name(test), "name 2"));
1063  CU_ASSERT_FATAL(!test_create(test));
1064 
1065  test_free(test);
1066  test = NULL;
1067  CU_PASS("test_free");
1068 
1069  CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1070  CU_ASSERT_FATAL(!test_get_by_name(test, "name 2"));
1071  db_value_reset(&object2_id);
1072  CU_ASSERT(!db_value_copy(&object2_id, test_id(test)));
1073  CU_ASSERT(!strcmp(test_name(test), "name 2"));
1074 
1075  test_free(test);
1076  test = NULL;
1077  CU_PASS("test_free");
1078 }
1079 
1081  int cmp = 0;
1082 
1083  CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1084  CU_ASSERT_FATAL(!test_get_by_id(test, &object2_id));
1085  CU_ASSERT(!db_value_cmp(test_id(test), &object2_id, &cmp));
1086  CU_ASSERT(!cmp);
1087  CU_ASSERT(!strcmp(test_name(test), "name 2"));
1088 
1089  test_free(test);
1090  test = NULL;
1091  CU_PASS("test_free");
1092 }
1093 
1095  CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1096  CU_ASSERT_FATAL(!test_get_by_id(test, &object2_id));
1097  CU_ASSERT_FATAL(!test_set_name(test, "name 3"));
1098  CU_ASSERT(!strcmp(test_name(test), "name 3"));
1099  CU_ASSERT_FATAL(!test_update(test));
1100 
1101  test_free(test);
1102  test = NULL;
1103  CU_PASS("test_free");
1104 
1105  CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1106  CU_ASSERT_FATAL(!test_get_by_id(test, &object2_id));
1107  CU_ASSERT(!strcmp(test_name(test), "name 3"));
1108 
1109  test_free(test);
1110  test = NULL;
1111  CU_PASS("test_free");
1112 }
1113 
1115  CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1116  CU_ASSERT_FATAL(!test_get_by_id(test, &object2_id));
1117  CU_ASSERT_FATAL(!test_delete(test));
1118 
1119  test_free(test);
1120  test = NULL;
1121  CU_PASS("test_free");
1122 
1123  CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1124  CU_ASSERT_FATAL(test_get_by_id(test, &object2_id));
1125 
1126  test_free(test);
1127  test = NULL;
1128  CU_PASS("test_free");
1129 }
1130 
1132  CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1133  CU_ASSERT_FATAL(!test_set_name(test, "name 3"));
1134  CU_ASSERT(!strcmp(test_name(test), "name 3"));
1135  CU_ASSERT_FATAL(!test_create(test));
1136 
1137  test_free(test);
1138  test = NULL;
1139  CU_PASS("test_free");
1140 
1141  CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1142  CU_ASSERT_FATAL(!test_get_by_name(test, "name 3"));
1143  db_value_reset(&object3_id);
1144  CU_ASSERT(!db_value_copy(&object3_id, test_id(test)));
1145  CU_ASSERT(!strcmp(test_name(test), "name 3"));
1146 
1147  test_free(test);
1148  test = NULL;
1149  CU_PASS("test_free");
1150 }
1151 
1153  CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1154  CU_ASSERT_FATAL(!test_get_by_id(test, &object3_id));
1155  CU_ASSERT_FATAL(!test_delete(test));
1156 
1157  test_free(test);
1158  test = NULL;
1159  CU_PASS("test_free");
1160 
1161  CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1162  CU_ASSERT_FATAL(test_get_by_id(test, &object3_id));
1163 
1164  test_free(test);
1165  test = NULL;
1166  CU_PASS("test_free");
1167 }
1168 
1170  const test_t* local_test;
1171  int count = 0;
1172 
1173  CU_ASSERT_PTR_NOT_NULL_FATAL((test_list = test_list_new(connection)));
1174  CU_ASSERT_FATAL(!test_list_get(test_list));
1175  local_test = test_list_begin(test_list);
1176  while (local_test) {
1177  count++;
1178  local_test = test_list_next(test_list);
1179  }
1180  CU_ASSERT(count == 3);
1181 
1182  test_list_free(test_list);
1183  test_list = NULL;
1184  CU_PASS("test_list_free");
1185 }
1186 
1188  CU_ASSERT_PTR_NOT_NULL_FATAL((test = test_new(connection)));
1189  CU_ASSERT(test_count_by_name(test, "test") == 1);
1190  CU_ASSERT(test_count_by_id(test, &object2_id) == 1);
1191  CU_ASSERT(test_count_by_id(test, &object3_id) == 1);
1192  CU_ASSERT(test_count_by_name(test, "name 3") == 2);
1193  test_free(test);
1194  test = NULL;
1195  CU_PASS("test_free");
1196 }
1197 
1199  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1200  CU_ASSERT_FATAL(!test2_get_by_name(test2, "test"));
1201  __check_id(test2_id(test2), 1, "1");
1202  CU_ASSERT_PTR_NOT_NULL_FATAL(test2_name(test2));
1203  CU_ASSERT(!strcmp(test2_name(test2), "test"));
1204 
1205  test2_free(test2);
1206  test2 = NULL;
1207  CU_PASS("test2_free");
1208 }
1209 
1211  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1212  CU_ASSERT_FATAL(!test2_set_name(test2, "name 2"));
1213  CU_ASSERT(!strcmp(test2_name(test2), "name 2"));
1214  CU_ASSERT_FATAL(!test2_create(test2));
1215 
1216  test2_free(test2);
1217  test2 = NULL;
1218  CU_PASS("test2_free");
1219 
1220  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1221  CU_ASSERT_FATAL(!test2_get_by_name(test2, "name 2"));
1222  db_value_reset(&object2_id);
1223  CU_ASSERT(!db_value_copy(&object2_id, test2_id(test2)));
1224  CU_ASSERT(!strcmp(test2_name(test2), "name 2"));
1225 
1226  test2_free(test2);
1227  test2 = NULL;
1228  CU_PASS("test2_free");
1229 }
1230 
1232  int cmp = 0;
1233 
1234  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1235  CU_ASSERT_FATAL(!test2_get_by_id(test2, &object2_id));
1236  CU_ASSERT(!db_value_cmp(test2_id(test2), &object2_id, &cmp));
1237  CU_ASSERT(!cmp);
1238  CU_ASSERT(!strcmp(test2_name(test2), "name 2"));
1239 
1240  test2_free(test2);
1241  test2 = NULL;
1242  CU_PASS("test2_free");
1243 }
1244 
1246  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1247  CU_ASSERT_FATAL(!test2_get_by_id(test2, &object2_id));
1248  CU_ASSERT_FATAL(!test2_set_name(test2, "name 3"));
1249  CU_ASSERT(!strcmp(test2_name(test2), "name 3"));
1250  CU_ASSERT_FATAL(!test2_update(test2));
1251 
1252  test2_free(test2);
1253  test2 = NULL;
1254  CU_PASS("test2_free");
1255 
1256  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1257  CU_ASSERT_FATAL(!test2_get_by_id(test2, &object2_id));
1258  CU_ASSERT(!strcmp(test2_name(test2), "name 3"));
1259 
1260  test2_free(test2);
1261  test2 = NULL;
1262  CU_PASS("test2_free");
1263 }
1264 
1266  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1267  CU_ASSERT_FATAL(!test2_set_name(test2, "name 4"));
1268  CU_ASSERT(!strcmp(test2_name(test2), "name 4"));
1269  CU_ASSERT_FATAL(!test2_create(test2));
1270 
1271  test2_free(test2);
1272  test2 = NULL;
1273  CU_PASS("test2_free");
1274 
1275  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1276  CU_ASSERT_FATAL(!test2_get_by_name(test2, "name 4"));
1277  CU_ASSERT(!strcmp(test2_name(test2), "name 4"));
1278 
1279  CU_ASSERT_PTR_NOT_NULL_FATAL((test2_2 = test2_new(connection)));
1280  CU_ASSERT_FATAL(!test2_get_by_name(test2_2, "name 4"));
1281  CU_ASSERT(!strcmp(test2_name(test2_2), "name 4"));
1282 
1283  CU_ASSERT_FATAL(!test2_set_name(test2_2, "name 5"));
1284  CU_ASSERT(!strcmp(test2_name(test2_2), "name 5"));
1285  CU_ASSERT_FATAL(!test2_update(test2_2));
1286 
1287  CU_ASSERT_FATAL(!test2_set_name(test2, "name 5"));
1288  CU_ASSERT(!strcmp(test2_name(test2), "name 5"));
1289  CU_ASSERT_FATAL(test2_update(test2));
1290 
1291  test2_free(test2);
1292  test2 = NULL;
1293  CU_PASS("test2_free");
1294 
1295  test2_free(test2_2);
1296  test2_2 = NULL;
1297  CU_PASS("test2_free");
1298 }
1299 
1301  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1302  CU_ASSERT_FATAL(!test2_get_by_id(test2, &object2_id));
1303  CU_ASSERT_FATAL(!test2_delete(test2));
1304 
1305  test2_free(test2);
1306  test2 = NULL;
1307  CU_PASS("test2_free");
1308 
1309  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1310  CU_ASSERT_FATAL(test2_get_by_id(test2, &object2_id));
1311 
1312  test2_free(test2);
1313  test2 = NULL;
1314  CU_PASS("test2_free");
1315 }
1316 
1318  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1319  CU_ASSERT_FATAL(!test2_set_name(test2, "name 3"));
1320  CU_ASSERT(!strcmp(test2_name(test2), "name 3"));
1321  CU_ASSERT_FATAL(!test2_create(test2));
1322 
1323  test2_free(test2);
1324  test2 = NULL;
1325  CU_PASS("test2_free");
1326 
1327  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1328  CU_ASSERT_FATAL(!test2_get_by_name(test2, "name 3"));
1329  db_value_reset(&object3_id);
1330  CU_ASSERT(!db_value_copy(&object3_id, test2_id(test2)));
1331  CU_ASSERT(!strcmp(test2_name(test2), "name 3"));
1332 
1333  test2_free(test2);
1334  test2 = NULL;
1335  CU_PASS("test2_free");
1336 }
1337 
1339  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1340  CU_ASSERT_FATAL(!test2_get_by_id(test2, &object3_id));
1341  CU_ASSERT_FATAL(!test2_delete(test2));
1342 
1343  test2_free(test2);
1344  test2 = NULL;
1345  CU_PASS("test2_free");
1346 
1347  CU_ASSERT_PTR_NOT_NULL_FATAL((test2 = test2_new(connection)));
1348  CU_ASSERT_FATAL(test2_get_by_id(test2, &object3_id));
1349 
1350  test2_free(test2);
1351  test2 = NULL;
1352  CU_PASS("test2_free");
1353 }
test2_t * test2_new(const db_connection_t *connection)
int init_suite_database_operations_mysql(void)
const test_t * test_list_next(test_list_t *test_list)
int db_object_set_object_field_list(db_object_t *object, db_object_field_list_t *object_field_list)
Definition: db_object.c:386
int db_object_set_primary_key_name(db_object_t *object, const char *primary_key_name)
Definition: db_object.c:371
int64_t db_type_int64_t
Definition: db_type.h:46
db_object_field_list_t * db_object_field_list_new(void)
Definition: db_object.c:174
int db_object_field_set_name(db_object_field_t *object_field, const char *name)
Definition: db_object.c:110
db_object_t * dbo
int db_connection_setup(db_connection_t *connection)
Definition: db_connection.c:66
const db_value_t * db_value_set_at(const db_value_set_t *value_set, size_t at)
Definition: db_value.c:742
void db_value_set_free(db_value_set_t *value_set)
Definition: db_value.c:697
int db_value_to_uint32(const db_value_t *value, db_type_uint32_t *to_uint32)
Definition: db_value.c:372
int db_value_to_uint64(const db_value_t *value, db_type_uint64_t *to_uint64)
Definition: db_value.c:402
void test_database_operations_count(void)
void __check_id(const db_value_t *id, int id_int, const char *id_text)
db_configuration_t * db_configuration_new(void)
int db_value_copy(db_value_t *value, const db_value_t *from_value)
Definition: db_value.c:77
db_clause_list_t * db_clause_list_new(void)
Definition: db_clause.c:202
size_t test_count_by_name(test_t *test, const char *name)
void db_value_free(db_value_t *value)
Definition: db_value.c:51
int test_set_name(test_t *test, const char *name)
int test2_delete(test2_t *test2)
void test_database_operations_create_object3_2(void)
db_clause_t * db_clause_new(void)
Definition: db_clause.c:43
int db_object_count(const db_object_t *object, const db_join_list_t *join_list, const db_clause_list_t *clause_list, size_t *count)
Definition: db_object.c:481
int db_object_field_set_type(db_object_field_t *object_field, db_type_t type)
Definition: db_object.c:122
int test2_from_result(test2_t *test2, const db_result_t *result)
int db_value_to_int64(const db_value_t *value, db_type_int64_t *to_int64)
Definition: db_value.c:387
int db_configuration_set_name(db_configuration_t *configuration, const char *name)
int db_clause_set_type(db_clause_t *clause, db_clause_type_t type)
Definition: db_clause.c:130
test_t * test_new(const db_connection_t *connection)
const char * test2_name(const test2_t *test2)
int db_object_set_connection(db_object_t *object, const db_connection_t *connection)
Definition: db_object.c:341
int test2_create(test2_t *test2)
db_value_t * id
void test_database_operations_read_object2_2(void)
int db_value_not_empty(const db_value_t *value)
Definition: db_value.c:347
int db_value_from_text(db_value_t *value, const char *from_text)
Definition: db_value.c:531
const db_connection_t * db_object_connection(const db_object_t *object)
Definition: db_object.c:320
void test_database_operations_create_object3(void)
db_object_t * dbo
const db_value_t * test2_id(const test2_t *test2)
int test2_get_by_id(test2_t *test2, const db_value_t *id)
void test_free(test_t *test)
int db_clause_set_field(db_clause_t *clause, const char *field)
Definition: db_clause.c:109
void db_clause_list_free(db_clause_list_t *clause_list)
Definition: db_clause.c:209
size_t db_value_set_size(const db_value_set_t *value_set)
Definition: db_value.c:734
int db_configuration_list_add(db_configuration_list_t *configuration_list, db_configuration_t *configuration)
void test_database_operations_delete_object2(void)
int test_update(test_t *test)
int test_from_result(test_t *test, const db_result_t *result)
int db_value_to_text(const db_value_t *value, char **to_text)
Definition: db_value.c:417
size_t test_count_by_id(test_t *test, const db_value_t *id)
int db_clause_list_add(db_clause_list_t *clause_list, db_clause_t *clause)
Definition: db_clause.c:226
int test2_get_by_name(test2_t *test2, const char *name)
int db_value_cmp(const db_value_t *value_a, const db_value_t *value_b, int *result)
Definition: db_value.c:102
db_result_list_t * db_object_read(const db_object_t *object, const db_join_list_t *join_list, const db_clause_list_t *clause_list)
Definition: db_object.c:424
void db_object_free(db_object_t *object)
Definition: db_object.c:311
void db_result_list_free(db_result_list_t *result_list)
Definition: db_result.c:160
void test_database_operations_update_object2(void)
int db_object_update(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)
Definition: db_object.c:441
void test_database_operations_read_object1_2(void)
db_result_list_t * result_list
void test_database_operations_delete_object2_2(void)
void test_database_operations_create_object2_2(void)
const char * test_name(const test_t *test)
int clean_suite_database_operations(void)
void db_configuration_free(db_configuration_t *configuration)
void db_value_reset(db_value_t *value)
Definition: db_value.c:60
void test_database_operations_delete_object3_2(void)
db_object_field_t * db_object_field_new(void)
Definition: db_object.c:40
int test_list_get(test_list_t *test_list)
int db_object_delete(const db_object_t *object, const db_clause_list_t *clause_list)
Definition: db_object.c:464
void test2_free(test2_t *test2)
int test_delete(test_t *test)
db_value_t * rev
void db_object_field_free(db_object_field_t *object_field)
Definition: db_object.c:69
void test_database_operations_read_all(void)
void db_clause_free(db_clause_t *clause)
Definition: db_clause.c:56
db_value_set_t * db_value_set_new(size_t size)
Definition: db_value.c:622
const db_result_t * db_result_list_next(db_result_list_t *result_list)
Definition: db_result.c:310
db_value_t * db_value_new()
Definition: db_value.c:40
int test2_update(test2_t *test2)
db_configuration_list_t * db_configuration_list_new(void)
int test_get_by_name(test_t *test, const char *name)
int32_t db_type_int32_t
Definition: db_type.h:38
int db_object_create(const db_object_t *object, const db_object_field_list_t *object_field_list, const db_value_set_t *value_set)
Definition: db_object.c:401
int test_create(test_t *test)
void db_object_field_list_free(db_object_field_list_t *object_field_list)
Definition: db_object.c:199
db_object_t * db_object_new(void)
Definition: db_object.c:304
void test_database_operations_read_object1(void)
void test_database_operations_update_object2_2(void)
void test_database_operations_delete_object3(void)
int db_connection_set_configuration_list(db_connection_t *connection, const db_configuration_list_t *configuration_list)
Definition: db_connection.c:54
db_object_t * __test2_new_object(const db_connection_t *connection)
void db_connection_free(db_connection_t *connection)
Definition: db_connection.c:45
test_list_t * test_list_new(const db_connection_t *connection)
void test_database_operations_update_objects_revisions(void)
const db_value_set_t * db_result_value_set(const db_result_t *result)
Definition: db_result.c:97
int db_object_set_table(db_object_t *object, const char *table)
Definition: db_object.c:356
const test_t * test_list_begin(test_list_t *test_list)
void test_database_operations_create_object2(void)
void test_database_operations_read_object2(void)
db_type_t db_value_type(const db_value_t *value)
Definition: db_value.c:269
db_object_t * __test_new_object(const db_connection_t *connection)
int db_configuration_set_value(db_configuration_t *configuration, const char *value)
int test2_set_name(test2_t *test2, const char *name)
void test_list_free(test_list_t *test_list)
const char * db_value_text(const db_value_t *value)
Definition: db_value.c:321
int db_connection_connect(const db_connection_t *connection)
Definition: db_connection.c:88
const db_value_t * test_id(const test_t *test)
uint64_t db_type_uint64_t
Definition: db_type.h:50
db_connection_t * db_connection_new(void)
Definition: db_connection.c:38
int test_get_by_id(test_t *test, const db_value_t *id)
uint32_t db_type_uint32_t
Definition: db_type.h:42
db_value_t * db_clause_get_value(db_clause_t *clause)
Definition: db_clause.c:187
db_value_t * db_value_set_get(db_value_set_t *value_set, size_t at)
Definition: db_value.c:756
int db_object_field_list_add(db_object_field_list_t *object_field_list, db_object_field_t *object_field)
Definition: db_object.c:254
void db_configuration_list_free(db_configuration_list_t *configuration_list)
int db_value_to_int32(const db_value_t *value, db_type_int32_t *to_int32)
Definition: db_value.c:357