ldb:tests: Add tests for case insensitive searches
[amitay/samba.git] / lib / ldb / tests / ldb_mod_op_test.c
1 /*
2  * from cmocka.c:
3  * These headers or their equivalents should be included prior to
4  * including
5  * this header file.
6  *
7  * #include <stdarg.h>
8  * #include <stddef.h>
9  * #include <setjmp.h>
10  *
11  * This allows test applications to use custom definitions of C standard
12  * library functions and types.
13  */
14 #include <stdarg.h>
15 #include <stddef.h>
16 #include <setjmp.h>
17 #include <cmocka.h>
18
19 #include <cmocka.h>
20
21 #include <errno.h>
22 #include <unistd.h>
23 #include <talloc.h>
24 #include <ldb.h>
25 #include <string.h>
26
27 #define DEFAULT_BE  "tdb"
28
29 #ifndef TEST_BE
30 #define TEST_BE DEFAULT_BE
31 #endif /* TEST_BE */
32
33 struct ldbtest_ctx {
34         struct tevent_context *ev;
35         struct ldb_context *ldb;
36
37         const char *dbfile;
38         const char *lockfile;   /* lockfile is separate */
39
40         const char *dbpath;
41 };
42
43 static void unlink_old_db(struct ldbtest_ctx *test_ctx)
44 {
45         int ret;
46
47         errno = 0;
48         ret = unlink(test_ctx->lockfile);
49         if (ret == -1 && errno != ENOENT) {
50                 fail();
51         }
52
53         errno = 0;
54         ret = unlink(test_ctx->dbfile);
55         if (ret == -1 && errno != ENOENT) {
56                 fail();
57         }
58 }
59
60 static int ldbtest_noconn_setup(void **state)
61 {
62         struct ldbtest_ctx *test_ctx;
63
64         test_ctx = talloc_zero(NULL, struct ldbtest_ctx);
65         assert_non_null(test_ctx);
66
67         test_ctx->ev = tevent_context_init(test_ctx);
68         assert_non_null(test_ctx->ev);
69
70         test_ctx->ldb = ldb_init(test_ctx, test_ctx->ev);
71         assert_non_null(test_ctx->ldb);
72
73         test_ctx->dbfile = talloc_strdup(test_ctx, "apitest.ldb");
74         assert_non_null(test_ctx->dbfile);
75
76         test_ctx->lockfile = talloc_asprintf(test_ctx, "%s-lock",
77                                              test_ctx->dbfile);
78         assert_non_null(test_ctx->lockfile);
79
80         test_ctx->dbpath = talloc_asprintf(test_ctx,
81                         TEST_BE"://%s", test_ctx->dbfile);
82         assert_non_null(test_ctx->dbpath);
83
84         unlink_old_db(test_ctx);
85         *state = test_ctx;
86         return 0;
87 }
88
89 static int ldbtest_noconn_teardown(void **state)
90 {
91         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
92                                                         struct ldbtest_ctx);
93
94         unlink_old_db(test_ctx);
95         talloc_free(test_ctx);
96         return 0;
97 }
98
99 static void test_connect(void **state)
100 {
101         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
102                                                         struct ldbtest_ctx);
103         int ret;
104
105         ret = ldb_connect(test_ctx->ldb, test_ctx->dbpath, 0, NULL);
106         assert_int_equal(ret, 0);
107 }
108
109 static int ldbtest_setup(void **state)
110 {
111         struct ldbtest_ctx *test_ctx;
112         int ret;
113
114         ldbtest_noconn_setup((void **) &test_ctx);
115
116         ret = ldb_connect(test_ctx->ldb, test_ctx->dbpath, 0, NULL);
117         assert_int_equal(ret, 0);
118
119         *state = test_ctx;
120         return 0;
121 }
122
123 static int ldbtest_teardown(void **state)
124 {
125         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
126                                                         struct ldbtest_ctx);
127         ldbtest_noconn_teardown((void **) &test_ctx);
128         return 0;
129 }
130
131 static void test_ldb_add(void **state)
132 {
133         int ret;
134         struct ldb_message *msg;
135         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
136                                                         struct ldbtest_ctx);
137         TALLOC_CTX *tmp_ctx;
138
139         tmp_ctx = talloc_new(test_ctx);
140         assert_non_null(tmp_ctx);
141
142         msg = ldb_msg_new(tmp_ctx);
143         assert_non_null(msg);
144
145         msg->dn = ldb_dn_new_fmt(msg, test_ctx->ldb, "dc=test");
146         assert_non_null(msg->dn);
147
148         ret = ldb_msg_add_string(msg, "cn", "test_cn_val");
149         assert_int_equal(ret, 0);
150
151         ret = ldb_add(test_ctx->ldb, msg);
152         assert_int_equal(ret, 0);
153
154         talloc_free(tmp_ctx);
155 }
156
157 static void test_ldb_search(void **state)
158 {
159         int ret;
160         struct ldb_message *msg;
161         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
162                                                         struct ldbtest_ctx);
163         TALLOC_CTX *tmp_ctx;
164         struct ldb_dn *basedn;
165         struct ldb_dn *basedn2;
166         struct ldb_result *result = NULL;
167
168         tmp_ctx = talloc_new(test_ctx);
169         assert_non_null(tmp_ctx);
170
171         basedn = ldb_dn_new_fmt(tmp_ctx, test_ctx->ldb, "dc=test");
172         assert_non_null(basedn);
173
174         ret = ldb_search(test_ctx->ldb, tmp_ctx, &result, basedn,
175                          LDB_SCOPE_BASE, NULL, NULL);
176         assert_int_equal(ret, 0);
177         assert_non_null(result);
178         assert_int_equal(result->count, 0);
179
180         msg = ldb_msg_new(tmp_ctx);
181         assert_non_null(msg);
182
183         msg->dn = basedn;
184         assert_non_null(msg->dn);
185
186         ret = ldb_msg_add_string(msg, "cn", "test_cn_val1");
187         assert_int_equal(ret, 0);
188
189         ret = ldb_add(test_ctx->ldb, msg);
190         assert_int_equal(ret, 0);
191
192         basedn2 = ldb_dn_new_fmt(tmp_ctx, test_ctx->ldb, "dc=test2");
193         assert_non_null(basedn2);
194
195         msg = ldb_msg_new(tmp_ctx);
196         assert_non_null(msg);
197
198         msg->dn = basedn2;
199         assert_non_null(msg->dn);
200
201         ret = ldb_msg_add_string(msg, "cn", "test_cn_val2");
202         assert_int_equal(ret, 0);
203
204         ret = ldb_add(test_ctx->ldb, msg);
205         assert_int_equal(ret, 0);
206
207         ret = ldb_search(test_ctx->ldb, tmp_ctx, &result, basedn,
208                          LDB_SCOPE_BASE, NULL, NULL);
209         assert_int_equal(ret, 0);
210         assert_non_null(result);
211         assert_int_equal(result->count, 1);
212         assert_string_equal(ldb_dn_get_linearized(result->msgs[0]->dn),
213                             ldb_dn_get_linearized(basedn));
214
215         ret = ldb_search(test_ctx->ldb, tmp_ctx, &result, basedn2,
216                          LDB_SCOPE_BASE, NULL, NULL);
217         assert_int_equal(ret, 0);
218         assert_non_null(result);
219         assert_int_equal(result->count, 1);
220         assert_string_equal(ldb_dn_get_linearized(result->msgs[0]->dn),
221                             ldb_dn_get_linearized(basedn2));
222
223         talloc_free(tmp_ctx);
224 }
225
226 static int base_search_count(struct ldbtest_ctx *test_ctx, const char *entry_dn)
227 {
228         TALLOC_CTX *tmp_ctx;
229         struct ldb_dn *basedn;
230         struct ldb_result *result = NULL;
231         int ret;
232         int count;
233
234         tmp_ctx = talloc_new(test_ctx);
235         assert_non_null(tmp_ctx);
236
237         basedn = ldb_dn_new_fmt(tmp_ctx, test_ctx->ldb, "%s", entry_dn);
238         assert_non_null(basedn);
239
240         ret = ldb_search(test_ctx->ldb, tmp_ctx, &result, basedn,
241                          LDB_SCOPE_BASE, NULL, NULL);
242         assert_int_equal(ret, LDB_SUCCESS);
243         assert_non_null(result);
244
245         count = result->count;
246         talloc_free(tmp_ctx);
247         return count;
248 }
249
250 static int sub_search_count(struct ldbtest_ctx *test_ctx,
251                             const char *base_dn,
252                             const char *filter)
253 {
254         TALLOC_CTX *tmp_ctx;
255         struct ldb_dn *basedn;
256         struct ldb_result *result = NULL;
257         int ret;
258         int count;
259
260         tmp_ctx = talloc_new(test_ctx);
261         assert_non_null(tmp_ctx);
262
263         basedn = ldb_dn_new_fmt(tmp_ctx, test_ctx->ldb, "%s", base_dn);
264         assert_non_null(basedn);
265
266         ret = ldb_search(test_ctx->ldb, tmp_ctx, &result, basedn,
267                          LDB_SCOPE_SUBTREE, NULL, "%s", filter);
268         assert_int_equal(ret, LDB_SUCCESS);
269         assert_non_null(result);
270
271         count = result->count;
272         talloc_free(tmp_ctx);
273         return count;
274 }
275
276 /* In general it would be better if utility test functions didn't assert
277  * but only returned a value, then assert in the test shows correct
278  * line
279  */
280 static void assert_dn_exists(struct ldbtest_ctx *test_ctx,
281                              const char *entry_dn)
282 {
283         int count;
284
285         count = base_search_count(test_ctx, entry_dn);
286         assert_int_equal(count, 1);
287 }
288
289 static void assert_dn_doesnt_exist(struct ldbtest_ctx *test_ctx,
290                                    const char *entry_dn)
291 {
292         int count;
293
294         count = base_search_count(test_ctx, entry_dn);
295         assert_int_equal(count, 0);
296 }
297
298 static void test_ldb_del(void **state)
299 {
300         int ret;
301         struct ldb_message *msg;
302         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
303                                                         struct ldbtest_ctx);
304         TALLOC_CTX *tmp_ctx;
305         const char *basedn = "dc=ldb_del_test";
306
307         tmp_ctx = talloc_new(test_ctx);
308         assert_non_null(tmp_ctx);
309
310         assert_dn_doesnt_exist(test_ctx, basedn);
311
312         msg = ldb_msg_new(tmp_ctx);
313         assert_non_null(msg);
314
315         msg->dn = ldb_dn_new_fmt(tmp_ctx, test_ctx->ldb, "%s", basedn);
316         assert_non_null(msg->dn);
317
318         ret = ldb_msg_add_string(msg, "cn", "test_del_cn_val");
319         assert_int_equal(ret, LDB_SUCCESS);
320
321         ret = ldb_add(test_ctx->ldb, msg);
322         assert_int_equal(ret, LDB_SUCCESS);
323
324         assert_dn_exists(test_ctx, basedn);
325
326         ret = ldb_delete(test_ctx->ldb, msg->dn);
327         assert_int_equal(ret, LDB_SUCCESS);
328
329         assert_dn_doesnt_exist(test_ctx, basedn);
330
331         talloc_free(tmp_ctx);
332 }
333
334 static void test_ldb_del_noexist(void **state)
335 {
336         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
337                                                              struct ldbtest_ctx);
338         struct ldb_dn *basedn;
339         int ret;
340
341         basedn = ldb_dn_new(test_ctx, test_ctx->ldb, "dc=nosuchplace");
342         assert_non_null(basedn);
343
344         ret = ldb_delete(test_ctx->ldb, basedn);
345         assert_int_equal(ret, LDB_ERR_NO_SUCH_OBJECT);
346 }
347
348 static void add_keyval(struct ldbtest_ctx *test_ctx,
349                        const char *key,
350                        const char *val)
351 {
352         int ret;
353         struct ldb_message *msg;
354
355         msg = ldb_msg_new(test_ctx);
356         assert_non_null(msg);
357
358         msg->dn = ldb_dn_new_fmt(msg, test_ctx->ldb, "%s=%s", key, val);
359         assert_non_null(msg->dn);
360
361         ret = ldb_msg_add_string(msg, key, val);
362         assert_int_equal(ret, 0);
363
364         ret = ldb_add(test_ctx->ldb, msg);
365         assert_int_equal(ret, 0);
366
367         talloc_free(msg);
368 }
369
370 static struct ldb_result *get_keyval(struct ldbtest_ctx *test_ctx,
371                                      const char *key,
372                                      const char *val)
373 {
374         int ret;
375         struct ldb_result *result;
376         struct ldb_dn *basedn;
377
378         basedn = ldb_dn_new_fmt(test_ctx, test_ctx->ldb, "%s=%s", key, val);
379         assert_non_null(basedn);
380
381         ret = ldb_search(test_ctx->ldb, test_ctx, &result, basedn,
382                         LDB_SCOPE_BASE, NULL, NULL);
383         assert_int_equal(ret, 0);
384
385         return result;
386 }
387
388 static void test_transactions(void **state)
389 {
390         int ret;
391         struct ldbtest_ctx *test_ctx = talloc_get_type_abort(*state,
392                         struct ldbtest_ctx);
393         struct ldb_result *res;
394
395         /* start lev-0 transaction */
396         ret = ldb_transaction_start(test_ctx->ldb);
397         assert_int_equal(ret, 0);
398
399         add_keyval(test_ctx, "vegetable", "carrot");
400
401         /* commit lev-0 transaction */
402         ret = ldb_transaction_commit(test_ctx->ldb);
403         assert_int_equal(ret, 0);
404
405         /* start another lev-1 nested transaction */
406         ret = ldb_transaction_start(test_ctx->ldb);
407         assert_int_equal(ret, 0);
408
409         add_keyval(test_ctx, "fruit", "apple");
410
411         /* abort lev-1 nested transaction */
412         ret = ldb_transaction_cancel(test_ctx->ldb);
413         assert_int_equal(ret, 0);
414
415         res = get_keyval(test_ctx, "vegetable", "carrot");
416         assert_non_null(res);
417         assert_int_equal(res->count, 1);
418
419         res = get_keyval(test_ctx, "fruit", "apple");
420         assert_non_null(res);
421         assert_int_equal(res->count, 0);
422 }
423
424 struct ldb_mod_test_ctx {
425         struct ldbtest_ctx *ldb_test_ctx;
426         const char *entry_dn;
427 };
428
429 struct keyval {
430         const char *key;
431         const char *val;
432 };
433
434 static struct ldb_message *build_mod_msg(TALLOC_CTX *mem_ctx,
435                                          struct ldbtest_ctx *test_ctx,
436                                          const char *dn,
437                                          int modify_flags,
438                                          struct keyval *kvs)
439 {
440         struct ldb_message *msg;
441         int ret;
442         int i;
443
444         msg = ldb_msg_new(mem_ctx);
445         assert_non_null(msg);
446
447         msg->dn = ldb_dn_new_fmt(msg, test_ctx->ldb, "%s", dn);
448         assert_non_null(msg->dn);
449
450         for (i = 0; kvs[i].key != NULL; i++) {
451                 if (modify_flags) {
452                         ret = ldb_msg_add_empty(msg, kvs[i].key,
453                                                 modify_flags, NULL);
454                         assert_int_equal(ret, 0);
455                 }
456
457                 if (kvs[i].val) {
458                         ret = ldb_msg_add_string(msg, kvs[i].key, kvs[i].val);
459                         assert_int_equal(ret, LDB_SUCCESS);
460                 }
461         }
462
463         return msg;
464 }
465
466 static void ldb_test_add_data(TALLOC_CTX *mem_ctx,
467                               struct ldbtest_ctx *ldb_test_ctx,
468                               const char *basedn,
469                               struct keyval *kvs)
470 {
471         TALLOC_CTX *tmp_ctx;
472         struct ldb_message *msg;
473         struct ldb_result *result = NULL;
474         int ret;
475
476         tmp_ctx = talloc_new(mem_ctx);
477         assert_non_null(tmp_ctx);
478
479         msg = build_mod_msg(tmp_ctx, ldb_test_ctx,
480                             basedn, 0, kvs);
481         assert_non_null(msg);
482
483         ret = ldb_add(ldb_test_ctx->ldb, msg);
484         assert_int_equal(ret, LDB_SUCCESS);
485
486         ret = ldb_search(ldb_test_ctx->ldb, tmp_ctx, &result, msg->dn,
487                          LDB_SCOPE_BASE, NULL, NULL);
488         assert_int_equal(ret, LDB_SUCCESS);
489         assert_non_null(result);
490         assert_int_equal(result->count, 1);
491         assert_string_equal(ldb_dn_get_linearized(result->msgs[0]->dn),
492                             ldb_dn_get_linearized(msg->dn));
493
494         talloc_free(tmp_ctx);
495 }
496
497 static void ldb_test_remove_data(TALLOC_CTX *mem_ctx,
498                                  struct ldbtest_ctx *ldb_test_ctx,
499                                  const char *strdn)
500 {
501         TALLOC_CTX *tmp_ctx;
502         struct ldb_result *result = NULL;
503         struct ldb_dn *basedn;
504         int ret;
505
506         tmp_ctx = talloc_new(mem_ctx);
507         assert_non_null(tmp_ctx);
508
509         basedn = ldb_dn_new_fmt(tmp_ctx, ldb_test_ctx->ldb,
510                                 "%s", strdn);
511         assert_non_null(basedn);
512
513         ret = ldb_delete(ldb_test_ctx->ldb, basedn);
514         assert_true(ret == LDB_SUCCESS || ret == LDB_ERR_NO_SUCH_OBJECT);
515
516         ret = ldb_search(ldb_test_ctx->ldb, tmp_ctx, &result, basedn,
517                         LDB_SCOPE_BASE, NULL, NULL);
518         assert_int_equal(ret, LDB_SUCCESS);
519         assert_non_null(result);
520         assert_int_equal(result->count, 0);
521
522         talloc_free(tmp_ctx);
523 }
524
525 static void mod_test_add_data(struct ldb_mod_test_ctx *mod_test_ctx,
526                               struct keyval *kvs)
527 {
528         ldb_test_add_data(mod_test_ctx,
529                           mod_test_ctx->ldb_test_ctx,
530                           mod_test_ctx->entry_dn,
531                           kvs);
532 }
533
534 static void mod_test_remove_data(struct ldb_mod_test_ctx *mod_test_ctx)
535 {
536         ldb_test_remove_data(mod_test_ctx,
537                              mod_test_ctx->ldb_test_ctx,
538                              mod_test_ctx->entry_dn);
539 }
540
541 static struct ldb_result *run_mod_test(struct ldb_mod_test_ctx *mod_test_ctx,
542                                        int modify_flags,
543                                        struct keyval *kvs)
544 {
545         TALLOC_CTX *tmp_ctx;
546         struct ldb_result *res;
547         struct ldb_message *mod_msg;
548         struct ldb_dn *basedn;
549         struct ldbtest_ctx *ldb_test_ctx;
550         int ret;
551
552         ldb_test_ctx = mod_test_ctx->ldb_test_ctx;
553
554         tmp_ctx = talloc_new(mod_test_ctx);
555         assert_non_null(tmp_ctx);
556
557         mod_msg = build_mod_msg(tmp_ctx, ldb_test_ctx, mod_test_ctx->entry_dn,
558                                 modify_flags, kvs);
559         assert_non_null(mod_msg);
560
561         ret = ldb_modify(ldb_test_ctx->ldb, mod_msg);
562         assert_int_equal(ret, LDB_SUCCESS);
563
564         basedn = ldb_dn_new_fmt(tmp_ctx, ldb_test_ctx->ldb,
565                         "%s", mod_test_ctx->entry_dn);
566         assert_non_null(basedn);
567
568         ret = ldb_search(ldb_test_ctx->ldb, mod_test_ctx, &res, basedn,
569                          LDB_SCOPE_BASE, NULL, NULL);
570         assert_int_equal(ret, LDB_SUCCESS);
571         assert_non_null(res);
572         assert_int_equal(res->count, 1);
573         assert_string_equal(ldb_dn_get_linearized(res->msgs[0]->dn),
574                             ldb_dn_get_linearized(mod_msg->dn));
575
576         talloc_free(tmp_ctx);
577         return res;
578 }
579
580 static int ldb_modify_test_setup(void **state)
581 {
582         struct ldbtest_ctx *ldb_test_ctx;
583         struct ldb_mod_test_ctx *mod_test_ctx;
584         struct keyval kvs[] = {
585                 { "cn", "test_mod_cn" },
586                 { NULL, NULL },
587         };
588
589         ldbtest_setup((void **) &ldb_test_ctx);
590
591         mod_test_ctx = talloc(ldb_test_ctx, struct ldb_mod_test_ctx);
592         assert_non_null(mod_test_ctx);
593
594         mod_test_ctx->entry_dn = "dc=mod_test_entry";
595         mod_test_ctx->ldb_test_ctx = ldb_test_ctx;
596
597         mod_test_remove_data(mod_test_ctx);
598         mod_test_add_data(mod_test_ctx, kvs);
599         *state = mod_test_ctx;
600         return 0;
601 }
602
603 static int ldb_modify_test_teardown(void **state)
604 {
605         struct ldb_mod_test_ctx *mod_test_ctx = \
606                                 talloc_get_type_abort(*state,
607                                                       struct ldb_mod_test_ctx);
608         struct ldbtest_ctx *ldb_test_ctx;
609
610         ldb_test_ctx = mod_test_ctx->ldb_test_ctx;
611
612         mod_test_remove_data(mod_test_ctx);
613         talloc_free(mod_test_ctx);
614
615         ldbtest_teardown((void **) &ldb_test_ctx);
616         return 0;
617 }
618
619 static void test_ldb_modify_add_key(void **state)
620 {
621         struct ldb_mod_test_ctx *mod_test_ctx = \
622                                 talloc_get_type_abort(*state,
623                                                       struct ldb_mod_test_ctx);
624         struct keyval mod_kvs[] = {
625                 { "name", "test_mod_name" },
626                 { NULL, NULL },
627         };
628         struct ldb_result *res;
629         struct ldb_message_element *el;
630
631         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_ADD, mod_kvs);
632         assert_non_null(res);
633
634         /* Check cn is intact and name was added */
635         assert_int_equal(res->count, 1);
636         el = ldb_msg_find_element(res->msgs[0], "cn");
637         assert_non_null(el);
638         assert_int_equal(el->num_values, 1);
639         assert_string_equal(el->values[0].data, "test_mod_cn");
640
641         el = ldb_msg_find_element(res->msgs[0], "name");
642         assert_non_null(el);
643         assert_int_equal(el->num_values, 1);
644         assert_string_equal(el->values[0].data, "test_mod_name");
645 }
646
647 static void test_ldb_modify_extend_key(void **state)
648 {
649         struct ldb_mod_test_ctx *mod_test_ctx = \
650                         talloc_get_type_abort(*state,
651                                               struct ldb_mod_test_ctx);
652         struct keyval mod_kvs[] = {
653                 { "cn", "test_mod_cn2" },
654                 { NULL, NULL },
655         };
656         struct ldb_result *res;
657         struct ldb_message_element *el;
658
659         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_ADD, mod_kvs);
660         assert_non_null(res);
661
662         /* Check cn was extended with another value */
663         assert_int_equal(res->count, 1);
664         el = ldb_msg_find_element(res->msgs[0], "cn");
665         assert_non_null(el);
666         assert_int_equal(el->num_values, 2);
667         assert_string_equal(el->values[0].data, "test_mod_cn");
668         assert_string_equal(el->values[1].data, "test_mod_cn2");
669 }
670
671 static void test_ldb_modify_add_key_noval(void **state)
672 {
673         struct ldb_mod_test_ctx *mod_test_ctx = \
674                         talloc_get_type_abort(*state,
675                                               struct ldb_mod_test_ctx);
676         struct ldb_message *mod_msg;
677         struct ldbtest_ctx *ldb_test_ctx;
678         struct ldb_message_element *el;
679         int ret;
680
681         ldb_test_ctx = mod_test_ctx->ldb_test_ctx;
682
683         mod_msg = ldb_msg_new(mod_test_ctx);
684         assert_non_null(mod_msg);
685
686         mod_msg->dn = ldb_dn_new_fmt(mod_msg, ldb_test_ctx->ldb,
687                         "%s", mod_test_ctx->entry_dn);
688         assert_non_null(mod_msg->dn);
689
690         el = talloc_zero(mod_msg, struct ldb_message_element);
691         el->flags = LDB_FLAG_MOD_ADD;
692         assert_non_null(el);
693         el->name = talloc_strdup(el, "cn");
694         assert_non_null(el->name);
695
696         mod_msg->elements = el;
697         mod_msg->num_elements = 1;
698
699         ret = ldb_modify(ldb_test_ctx->ldb, mod_msg);
700         assert_int_equal(ret, LDB_ERR_CONSTRAINT_VIOLATION);
701 }
702
703 static void test_ldb_modify_replace_key(void **state)
704 {
705         struct ldb_mod_test_ctx *mod_test_ctx = \
706                         talloc_get_type_abort(*state,
707                                               struct ldb_mod_test_ctx);
708         const char *new_cn = "new_cn";
709         struct keyval mod_kvs[] = {
710                 { "cn", new_cn },
711                 { NULL, NULL },
712         };
713         struct ldb_result *res;
714         struct ldb_message_element *el;
715
716         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_REPLACE, mod_kvs);
717         assert_non_null(res);
718
719         /* Check cn was replaced */
720         assert_int_equal(res->count, 1);
721         el = ldb_msg_find_element(res->msgs[0], "cn");
722         assert_non_null(el);
723         assert_int_equal(el->num_values, 1);
724         assert_string_equal(el->values[0].data, new_cn);
725 }
726
727 static void test_ldb_modify_replace_noexist_key(void **state)
728 {
729         struct ldb_mod_test_ctx *mod_test_ctx = \
730                         talloc_get_type_abort(*state,
731                                               struct ldb_mod_test_ctx);
732         struct keyval mod_kvs[] = {
733                 { "name", "name_val" },
734                 { NULL, NULL },
735         };
736         struct ldb_result *res;
737         struct ldb_message_element *el;
738
739         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_REPLACE, mod_kvs);
740         assert_non_null(res);
741
742         /* Check cn is intact and name was added */
743         assert_int_equal(res->count, 1);
744         el = ldb_msg_find_element(res->msgs[0], "cn");
745         assert_non_null(el);
746         assert_int_equal(el->num_values, 1);
747         assert_string_equal(el->values[0].data, "test_mod_cn");
748
749         el = ldb_msg_find_element(res->msgs[0], mod_kvs[0].key);
750         assert_non_null(el);
751         assert_int_equal(el->num_values, 1);
752         assert_string_equal(el->values[0].data, mod_kvs[0].val);
753 }
754
755 static void test_ldb_modify_replace_zero_vals(void **state)
756 {
757         struct ldb_mod_test_ctx *mod_test_ctx = \
758                         talloc_get_type_abort(*state,
759                                               struct ldb_mod_test_ctx);
760         struct ldb_message_element *el;
761         struct ldb_result *res;
762         struct keyval kvs[] = {
763                 { "cn", NULL },
764                 { NULL, NULL },
765         };
766
767         /* cn must be gone */
768         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_REPLACE, kvs);
769         assert_non_null(res);
770         el = ldb_msg_find_element(res->msgs[0], "cn");
771         assert_null(el);
772 }
773
774 static void test_ldb_modify_replace_noexist_key_zero_vals(void **state)
775 {
776         struct ldb_mod_test_ctx *mod_test_ctx = \
777                         talloc_get_type_abort(*state,
778                                               struct ldb_mod_test_ctx);
779         struct ldb_message_element *el;
780         struct ldb_result *res;
781         struct keyval kvs[] = {
782                 { "noexist_key", NULL },
783                 { NULL, NULL },
784         };
785
786         /* cn must be gone */
787         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_REPLACE, kvs);
788         assert_non_null(res);
789
790         /* cn should be intact */
791         el = ldb_msg_find_element(res->msgs[0], "cn");
792         assert_non_null(el);
793 }
794
795 static void test_ldb_modify_del_key(void **state)
796 {
797         struct ldb_mod_test_ctx *mod_test_ctx = \
798                         talloc_get_type_abort(*state,
799                                               struct ldb_mod_test_ctx);
800         struct ldb_message_element *el;
801         struct ldb_result *res;
802         struct keyval kvs[] = {
803                 { "cn", NULL },
804                 { NULL, NULL },
805         };
806
807         /* cn must be gone */
808         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_DELETE, kvs);
809         assert_non_null(res);
810
811         el = ldb_msg_find_element(res->msgs[0], "cn");
812         assert_null(el);
813 }
814
815 static void test_ldb_modify_del_keyval(void **state)
816 {
817         struct ldb_mod_test_ctx *mod_test_ctx = \
818                         talloc_get_type_abort(*state,
819                                               struct ldb_mod_test_ctx);
820         struct ldb_message_element *el;
821         struct ldb_result *res;
822         struct keyval kvs[] = {
823                 { "cn", "test_mod_cn" },
824                 { NULL, NULL },
825         };
826
827         /* cn must be gone */
828         res = run_mod_test(mod_test_ctx, LDB_FLAG_MOD_DELETE, kvs);
829         assert_non_null(res);
830
831         el = ldb_msg_find_element(res->msgs[0], "cn");
832         assert_null(el);
833 }
834
835 struct search_test_ctx {
836         struct ldbtest_ctx *ldb_test_ctx;
837         const char *base_dn;
838 };
839
840 static char *get_full_dn(TALLOC_CTX *mem_ctx,
841                          struct search_test_ctx *search_test_ctx,
842                          const char *rdn)
843 {
844         char *full_dn;
845
846         full_dn = talloc_asprintf(mem_ctx,
847                                   "%s,%s", rdn, search_test_ctx->base_dn);
848         assert_non_null(full_dn);
849
850         return full_dn;
851 }
852
853 static void search_test_add_data(struct search_test_ctx *search_test_ctx,
854                                  const char *rdn,
855                                  struct keyval *kvs)
856 {
857         char *full_dn;
858
859         full_dn = get_full_dn(search_test_ctx, search_test_ctx, rdn);
860
861         ldb_test_add_data(search_test_ctx,
862                           search_test_ctx->ldb_test_ctx,
863                           full_dn,
864                           kvs);
865 }
866
867 static void search_test_remove_data(struct search_test_ctx *search_test_ctx,
868                                     const char *rdn)
869 {
870         char *full_dn;
871
872         full_dn = talloc_asprintf(search_test_ctx,
873                                   "%s,%s", rdn, search_test_ctx->base_dn);
874         assert_non_null(full_dn);
875
876         ldb_test_remove_data(search_test_ctx,
877                              search_test_ctx->ldb_test_ctx,
878                              full_dn);
879 }
880
881 static int ldb_search_test_setup(void **state)
882 {
883         struct ldbtest_ctx *ldb_test_ctx;
884         struct search_test_ctx *search_test_ctx;
885         struct keyval kvs[] = {
886                 { "cn", "test_search_cn" },
887                 { "cn", "test_search_cn2" },
888                 { "uid", "test_search_uid" },
889                 { "uid", "test_search_uid2" },
890                 { NULL, NULL },
891         };
892         struct keyval kvs2[] = {
893                 { "cn", "test_search_2_cn" },
894                 { "cn", "test_search_2_cn2" },
895                 { "uid", "test_search_2_uid" },
896                 { "uid", "test_search_2_uid2" },
897                 { NULL, NULL },
898         };
899
900         ldbtest_setup((void **) &ldb_test_ctx);
901
902         search_test_ctx = talloc(ldb_test_ctx, struct search_test_ctx);
903         assert_non_null(search_test_ctx);
904
905         search_test_ctx->base_dn = "dc=search_test_entry";
906         search_test_ctx->ldb_test_ctx = ldb_test_ctx;
907
908         search_test_remove_data(search_test_ctx, "cn=test_search_cn");
909         search_test_add_data(search_test_ctx, "cn=test_search_cn", kvs);
910
911         search_test_remove_data(search_test_ctx, "cn=test_search_2_cn");
912         search_test_add_data(search_test_ctx, "cn=test_search_2_cn", kvs2);
913
914         *state = search_test_ctx;
915         return 0;
916 }
917
918 static int ldb_search_test_teardown(void **state)
919 {
920         struct search_test_ctx *search_test_ctx = talloc_get_type_abort(*state,
921                         struct search_test_ctx);
922         struct ldbtest_ctx *ldb_test_ctx;
923
924         ldb_test_ctx = search_test_ctx->ldb_test_ctx;
925
926         search_test_remove_data(search_test_ctx, "cn=test_search_cn");
927         search_test_remove_data(search_test_ctx, "cn=test_search_2_cn");
928         ldbtest_teardown((void **) &ldb_test_ctx);
929         return 0;
930 }
931
932 static void assert_attr_has_vals(struct ldb_message *msg,
933                                  const char *attr,
934                                  const char *vals[],
935                                  const size_t nvals)
936 {
937         struct ldb_message_element *el;
938         size_t i;
939
940         el = ldb_msg_find_element(msg, attr);
941         assert_non_null(el);
942
943         assert_int_equal(el->num_values, nvals);
944         for (i = 0; i < nvals; i++) {
945                 assert_string_equal(el->values[i].data,
946                                     vals[i]);
947         }
948 }
949
950 static void assert_has_no_attr(struct ldb_message *msg,
951                                const char *attr)
952 {
953         struct ldb_message_element *el;
954
955         el = ldb_msg_find_element(msg, attr);
956         assert_null(el);
957 }
958
959 static bool has_dn(struct ldb_message *msg, const char *dn)
960 {
961         const char *msgdn;
962
963         msgdn = ldb_dn_get_linearized(msg->dn);
964         if (strcmp(dn, msgdn) == 0) {
965                 return true;
966         }
967
968         return false;
969 }
970
971 static void test_search_match_none(void **state)
972 {
973         struct search_test_ctx *search_test_ctx = talloc_get_type_abort(*state,
974                         struct search_test_ctx);
975         int ret;
976         struct ldb_dn *basedn;
977         struct ldb_result *result = NULL;
978
979         basedn = ldb_dn_new_fmt(search_test_ctx,
980                                 search_test_ctx->ldb_test_ctx->ldb,
981                                 "%s",
982                                 search_test_ctx->base_dn);
983         assert_non_null(basedn);
984
985         ret = ldb_search(search_test_ctx->ldb_test_ctx->ldb,
986                          search_test_ctx,
987                          &result,
988                          basedn,
989                          LDB_SCOPE_SUBTREE, NULL,
990                          "dc=no_such_entry");
991         assert_int_equal(ret, 0);
992         assert_non_null(result);
993         assert_int_equal(result->count, 0);
994 }
995
996 static void test_search_match_one(void **state)
997 {
998         struct search_test_ctx *search_test_ctx = talloc_get_type_abort(*state,
999                         struct search_test_ctx);
1000         int ret;
1001         struct ldb_dn *basedn;
1002         struct ldb_result *result = NULL;
1003         const char *cn_vals[] = { "test_search_cn",
1004                                   "test_search_cn2" };
1005         const char *uid_vals[] = { "test_search_uid",
1006                                    "test_search_uid2" };
1007
1008         basedn = ldb_dn_new_fmt(search_test_ctx,
1009                                 search_test_ctx->ldb_test_ctx->ldb,
1010                                 "%s",
1011                                 search_test_ctx->base_dn);
1012         assert_non_null(basedn);
1013
1014         ret = ldb_search(search_test_ctx->ldb_test_ctx->ldb,
1015                          search_test_ctx,
1016                          &result,
1017                          basedn,
1018                          LDB_SCOPE_SUBTREE, NULL,
1019                          "cn=test_search_cn");
1020         assert_int_equal(ret, 0);
1021         assert_non_null(result);
1022         assert_int_equal(result->count, 1);
1023
1024         assert_attr_has_vals(result->msgs[0], "cn", cn_vals, 2);
1025         assert_attr_has_vals(result->msgs[0], "uid", uid_vals, 2);
1026 }
1027
1028 static void test_search_match_filter(void **state)
1029 {
1030         struct search_test_ctx *search_test_ctx = talloc_get_type_abort(*state,
1031                         struct search_test_ctx);
1032         int ret;
1033         struct ldb_dn *basedn;
1034         struct ldb_result *result = NULL;
1035         const char *cn_vals[] = { "test_search_cn",
1036                                   "test_search_cn2" };
1037         const char *attrs[] = { "cn", NULL };
1038
1039         basedn = ldb_dn_new_fmt(search_test_ctx,
1040                                 search_test_ctx->ldb_test_ctx->ldb,
1041                                 "%s",
1042                                 search_test_ctx->base_dn);
1043         assert_non_null(basedn);
1044
1045         ret = ldb_search(search_test_ctx->ldb_test_ctx->ldb,
1046                          search_test_ctx,
1047                          &result,
1048                          basedn,
1049                          LDB_SCOPE_SUBTREE,
1050                          attrs,
1051                          "cn=test_search_cn");
1052         assert_int_equal(ret, 0);
1053         assert_non_null(result);
1054         assert_int_equal(result->count, 1);
1055
1056         assert_attr_has_vals(result->msgs[0], "cn", cn_vals, 2);
1057         assert_has_no_attr(result->msgs[0], "uid");
1058 }
1059
1060 static void assert_expected(struct search_test_ctx *search_test_ctx,
1061                             struct ldb_message *msg)
1062 {
1063         char *full_dn1;
1064         char *full_dn2;
1065         const char *cn_vals[] = { "test_search_cn",
1066                                   "test_search_cn2" };
1067         const char *uid_vals[] = { "test_search_uid",
1068                                    "test_search_uid2" };
1069         const char *cn2_vals[] = { "test_search_2_cn",
1070                                    "test_search_2_cn2" };
1071         const char *uid2_vals[] = { "test_search_2_uid",
1072                                     "test_search_2_uid2" };
1073
1074         full_dn1 = get_full_dn(search_test_ctx,
1075                                search_test_ctx,
1076                                "cn=test_search_cn");
1077
1078         full_dn2 = get_full_dn(search_test_ctx,
1079                                search_test_ctx,
1080                                "cn=test_search_2_cn");
1081
1082         if (has_dn(msg, full_dn1) == true) {
1083                 assert_attr_has_vals(msg, "cn", cn_vals, 2);
1084                 assert_attr_has_vals(msg, "uid", uid_vals, 2);
1085         } else if (has_dn(msg, full_dn2) == true) {
1086                 assert_attr_has_vals(msg, "cn", cn2_vals, 2);
1087                 assert_attr_has_vals(msg, "uid", uid2_vals, 2);
1088         } else {
1089                 fail();
1090         }
1091 }
1092
1093 static void test_search_match_both(void **state)
1094 {
1095         struct search_test_ctx *search_test_ctx = talloc_get_type_abort(*state,
1096                         struct search_test_ctx);
1097         int ret;
1098         struct ldb_dn *basedn;
1099         struct ldb_result *result = NULL;
1100
1101         basedn = ldb_dn_new_fmt(search_test_ctx,
1102                                 search_test_ctx->ldb_test_ctx->ldb,
1103                                 "%s",
1104                                 search_test_ctx->base_dn);
1105         assert_non_null(basedn);
1106
1107         ret = ldb_search(search_test_ctx->ldb_test_ctx->ldb,
1108                          search_test_ctx,
1109                          &result,
1110                          basedn,
1111                          LDB_SCOPE_SUBTREE, NULL,
1112                          "cn=test_search_*");
1113         assert_int_equal(ret, 0);
1114         assert_non_null(result);
1115         assert_int_equal(result->count, 2);
1116
1117         assert_expected(search_test_ctx, result->msgs[0]);
1118         assert_expected(search_test_ctx, result->msgs[1]);
1119 }
1120
1121 static void test_search_match_basedn(void **state)
1122 {
1123         struct search_test_ctx *search_test_ctx = talloc_get_type_abort(*state,
1124                         struct search_test_ctx);
1125         int ret;
1126         struct ldb_dn *basedn;
1127         struct ldb_result *result = NULL;
1128         struct ldb_message *msg;
1129
1130         basedn = ldb_dn_new_fmt(search_test_ctx,
1131                                 search_test_ctx->ldb_test_ctx->ldb,
1132                                 "dc=nosuchdn");
1133         assert_non_null(basedn);
1134
1135         ret = ldb_search(search_test_ctx->ldb_test_ctx->ldb,
1136                          search_test_ctx,
1137                          &result,
1138                          basedn,
1139                          LDB_SCOPE_SUBTREE, NULL,
1140                          "cn=*");
1141         assert_int_equal(ret, 0);
1142
1143         /* Add 'checkBaseOnSearch' to @OPTIONS */
1144         msg = ldb_msg_new(search_test_ctx);
1145         assert_non_null(msg);
1146
1147         msg->dn = ldb_dn_new_fmt(msg,
1148                                  search_test_ctx->ldb_test_ctx->ldb,
1149                                  "@OPTIONS");
1150         assert_non_null(msg->dn);
1151
1152         ret = ldb_msg_add_string(msg, "checkBaseOnSearch", "TRUE");
1153         assert_int_equal(ret, 0);
1154
1155         ret = ldb_add(search_test_ctx->ldb_test_ctx->ldb, msg);
1156         assert_int_equal(ret, 0);
1157
1158         /* Search again */
1159         /* The search should return LDB_ERR_NO_SUCH_OBJECT */
1160         ret = ldb_search(search_test_ctx->ldb_test_ctx->ldb,
1161                          search_test_ctx,
1162                          &result,
1163                          basedn,
1164                          LDB_SCOPE_SUBTREE, NULL,
1165                          "cn=*");
1166         assert_int_equal(ret, LDB_ERR_NO_SUCH_OBJECT);
1167
1168         ret = ldb_delete(search_test_ctx->ldb_test_ctx->ldb, msg->dn);
1169         assert_int_equal(ret, 0);
1170 }
1171
1172 static int ldb_case_test_setup(void **state)
1173 {
1174         int ret;
1175         struct ldb_ldif *ldif;
1176         struct ldbtest_ctx *ldb_test_ctx;
1177         const char *attrs_ldif =  \
1178                 "dn: @ATTRIBUTES\n"
1179                 "cn: CASE_INSENSITIVE\n"
1180                 "\n";
1181         struct keyval kvs[] = {
1182                 { "cn", "CaseInsensitiveValue" },
1183                 { "uid", "CaseSensitiveValue" },
1184                 { NULL, NULL },
1185         };
1186
1187
1188         ldbtest_setup((void **) &ldb_test_ctx);
1189
1190         while ((ldif = ldb_ldif_read_string(ldb_test_ctx->ldb, &attrs_ldif))) {
1191                 ret = ldb_add(ldb_test_ctx->ldb, ldif->msg);
1192                 assert_int_equal(ret, LDB_SUCCESS);
1193         }
1194
1195         ldb_test_add_data(ldb_test_ctx,
1196                           ldb_test_ctx,
1197                           "cn=CaseInsensitiveValue",
1198                           kvs);
1199
1200         *state = ldb_test_ctx;
1201         return 0;
1202 }
1203
1204 static int ldb_case_test_teardown(void **state)
1205 {
1206         int ret;
1207         struct ldbtest_ctx *ldb_test_ctx = talloc_get_type_abort(*state,
1208                         struct ldbtest_ctx);
1209
1210         struct ldb_dn *del_dn;
1211
1212         del_dn = ldb_dn_new_fmt(ldb_test_ctx,
1213                                 ldb_test_ctx->ldb,
1214                                 "@ATTRIBUTES");
1215         assert_non_null(del_dn);
1216
1217         ret = ldb_delete(ldb_test_ctx->ldb, del_dn);
1218         assert_int_equal(ret, LDB_SUCCESS);
1219
1220         assert_dn_doesnt_exist(ldb_test_ctx,
1221                                "@ATTRIBUTES");
1222
1223         ldb_test_remove_data(ldb_test_ctx, ldb_test_ctx,
1224                              "cn=CaseInsensitiveValue");
1225
1226         ldbtest_teardown((void **) &ldb_test_ctx);
1227         return 0;
1228 }
1229
1230 static void test_ldb_attrs_case_insensitive(void **state)
1231 {
1232         int cnt;
1233         struct ldbtest_ctx *ldb_test_ctx = talloc_get_type_abort(*state,
1234                         struct ldbtest_ctx);
1235
1236         /* cn matches exact case */
1237         cnt = sub_search_count(ldb_test_ctx, "", "cn=CaseInsensitiveValue");
1238         assert_int_equal(cnt, 1);
1239
1240         /* cn matches lower case */
1241         cnt = sub_search_count(ldb_test_ctx, "", "cn=caseinsensitivevalue");
1242         assert_int_equal(cnt, 1);
1243
1244         /* uid matches exact case */
1245         cnt = sub_search_count(ldb_test_ctx, "", "uid=CaseSensitiveValue");
1246         assert_int_equal(cnt, 1);
1247
1248         /* uid does not match lower case */
1249         cnt = sub_search_count(ldb_test_ctx, "", "uid=casesensitivevalue");
1250         assert_int_equal(cnt, 0);
1251 }
1252
1253 int main(int argc, const char **argv)
1254 {
1255         const struct CMUnitTest tests[] = {
1256                 cmocka_unit_test_setup_teardown(test_connect,
1257                                                 ldbtest_noconn_setup,
1258                                                 ldbtest_noconn_teardown),
1259                 cmocka_unit_test_setup_teardown(test_ldb_add,
1260                                                 ldbtest_setup,
1261                                                 ldbtest_teardown),
1262                 cmocka_unit_test_setup_teardown(test_ldb_search,
1263                                                 ldbtest_setup,
1264                                                 ldbtest_teardown),
1265                 cmocka_unit_test_setup_teardown(test_ldb_del,
1266                                                 ldbtest_setup,
1267                                                 ldbtest_teardown),
1268                 cmocka_unit_test_setup_teardown(test_ldb_del_noexist,
1269                                                 ldbtest_setup,
1270                                                 ldbtest_teardown),
1271                 cmocka_unit_test_setup_teardown(test_transactions,
1272                                                 ldbtest_setup,
1273                                                 ldbtest_teardown),
1274                 cmocka_unit_test_setup_teardown(test_ldb_modify_add_key,
1275                                                 ldb_modify_test_setup,
1276                                                 ldb_modify_test_teardown),
1277                 cmocka_unit_test_setup_teardown(test_ldb_modify_extend_key,
1278                                                 ldb_modify_test_setup,
1279                                                 ldb_modify_test_teardown),
1280                 cmocka_unit_test_setup_teardown(test_ldb_modify_add_key_noval,
1281                                                 ldb_modify_test_setup,
1282                                                 ldb_modify_test_teardown),
1283                 cmocka_unit_test_setup_teardown(test_ldb_modify_replace_key,
1284                                                 ldb_modify_test_setup,
1285                                                 ldb_modify_test_teardown),
1286                 cmocka_unit_test_setup_teardown(test_ldb_modify_replace_noexist_key,
1287                                                 ldb_modify_test_setup,
1288                                                 ldb_modify_test_teardown),
1289                 cmocka_unit_test_setup_teardown(test_ldb_modify_replace_zero_vals,
1290                                                 ldb_modify_test_setup,
1291                                                 ldb_modify_test_teardown),
1292                 cmocka_unit_test_setup_teardown(test_ldb_modify_replace_noexist_key_zero_vals,
1293                                                 ldb_modify_test_setup,
1294                                                 ldb_modify_test_teardown),
1295                 cmocka_unit_test_setup_teardown(test_ldb_modify_del_key,
1296                                                 ldb_modify_test_setup,
1297                                                 ldb_modify_test_teardown),
1298                 cmocka_unit_test_setup_teardown(test_ldb_modify_del_keyval,
1299                                                 ldb_modify_test_setup,
1300                                                 ldb_modify_test_teardown),
1301                 cmocka_unit_test_setup_teardown(test_search_match_none,
1302                                                 ldb_search_test_setup,
1303                                                 ldb_search_test_teardown),
1304                 cmocka_unit_test_setup_teardown(test_search_match_one,
1305                                                 ldb_search_test_setup,
1306                                                 ldb_search_test_teardown),
1307                 cmocka_unit_test_setup_teardown(test_search_match_filter,
1308                                                 ldb_search_test_setup,
1309                                                 ldb_search_test_teardown),
1310                 cmocka_unit_test_setup_teardown(test_search_match_both,
1311                                                 ldb_search_test_setup,
1312                                                 ldb_search_test_teardown),
1313                 cmocka_unit_test_setup_teardown(test_search_match_basedn,
1314                                                 ldb_search_test_setup,
1315                                                 ldb_search_test_teardown),
1316                 cmocka_unit_test_setup_teardown(test_ldb_attrs_case_insensitive,
1317                                                 ldb_case_test_setup,
1318                                                 ldb_case_test_teardown),
1319         };
1320
1321         return cmocka_run_group_tests(tests, NULL, NULL);
1322 }