void testCheckDuplicates2(void) { bson b, b2; bson_iterator it, sit; bson_type bt; bson_init(&b); bson_append_start_array(&b, "array"); bson_append_int(&b, "0", 1); bson_append_finish_array(&b); bson_append_start_array(&b, "array"); bson_append_int(&b, "0", 3); bson_append_int(&b, "1", 4); bson_append_finish_array(&b); bson_finish(&b); CU_ASSERT_FALSE_FATAL(b.err); CU_ASSERT_TRUE_FATAL(bson_check_duplicate_keys(&b)); bson_init(&b2); bson_fix_duplicate_keys(&b, &b2); bson_finish(&b2); CU_ASSERT_FALSE_FATAL(b2.err); CU_ASSERT_FALSE_FATAL(bson_check_duplicate_keys(&b2)); BSON_ITERATOR_INIT(&it, &b2); bt = bson_iterator_next(&it); CU_ASSERT_EQUAL_FATAL(bt, BSON_ARRAY); CU_ASSERT_STRING_EQUAL_FATAL(BSON_ITERATOR_KEY(&it), "array"); BSON_ITERATOR_SUBITERATOR(&it, &sit); bt = bson_iterator_next(&sit); CU_ASSERT_STRING_EQUAL_FATAL(BSON_ITERATOR_KEY(&sit), "0"); CU_ASSERT_TRUE_FATAL(BSON_IS_NUM_TYPE(bt)); CU_ASSERT_EQUAL_FATAL(bson_iterator_int(&sit), 1); bt = bson_iterator_next(&sit); CU_ASSERT_STRING_EQUAL_FATAL(BSON_ITERATOR_KEY(&sit), "1"); CU_ASSERT_TRUE_FATAL(BSON_IS_NUM_TYPE(bt)); CU_ASSERT_EQUAL_FATAL(bson_iterator_int(&sit), 3); bt = bson_iterator_next(&sit); CU_ASSERT_STRING_EQUAL_FATAL(BSON_ITERATOR_KEY(&sit), "2"); CU_ASSERT_TRUE_FATAL(BSON_IS_NUM_TYPE(bt)); CU_ASSERT_EQUAL_FATAL(bson_iterator_int(&sit), 4); bt = bson_iterator_next(&sit); CU_ASSERT_EQUAL_FATAL(bt, BSON_EOO); bson_destroy(&b2); bson_destroy(&b); }
/** * @brief fo_tableExists() tests: * - Check for an existing table * - Check for table that does not exist * - Check for a non table entities (sequence, constraint, ...) * @return void */ void test_fo_tableExists() { PGconn* pgConn; int nonexistant_table; int existing_table; char* DBConfFile = dbConf; char* ErrorBuf; pgConn = fo_dbconnect(DBConfFile, &ErrorBuf); CU_ASSERT_PTR_NOT_NULL(pgConn); nonexistant_table = fo_tableExists(pgConn, "nonexistanttable"); CU_ASSERT_FALSE(nonexistant_table); PGresult* result = PQexec(pgConn, "CREATE table exists()"); CU_ASSERT_PTR_NOT_NULL_FATAL(result); CU_ASSERT_FALSE_FATAL(fo_checkPQcommand(pgConn, result, "create", __FILE__, __LINE__)); existing_table = fo_tableExists(pgConn, "exists"); CU_ASSERT_TRUE(existing_table); PQfinish(pgConn); return; }
void test_cancel() { T1 t1, t2; CU_ASSERT_TRUE_FATAL(t1.cancel()); t2.start(); CU_ASSERT_FALSE_FATAL(t2.cancel()); t2.stop(); }
static void test_open_on_dev_null_if_closed( void) { int status = close(STDERR_FILENO); CU_ASSERT_EQUAL_FATAL(status, 0); status = open_on_dev_null_if_closed(STDERR_FILENO, O_RDWR); CU_ASSERT_EQUAL_FATAL(status, 0); CU_ASSERT_FALSE_FATAL(log_is_stderr_useful()); CU_ASSERT_TRUE_FATAL(fcntl(STDERR_FILENO, F_GETFD) >= 0); }
void test_initialize_record(void) { record = NULL; initialize_record(&record, SIZE); int i; for (i = 0; i < SIZE; i++) { CU_ASSERT_EQUAL_FATAL(record->members[i], i + 1); CU_ASSERT_EQUAL_FATAL(record->index[i], i); CU_ASSERT_FALSE_FATAL(record->direction[i]); } }
void test_current() { StdThreadRepository& tr = StdThreadRepository::instance(); // this thread is not registered; CU_ASSERT_PTR_NULL_FATAL(RT::current()); CU_ASSERT_EQUAL_FATAL(tr.size(), 0); T1* thread1 = T1::create<T1>("thread1"); T1* thread2 = T1::create<T1>("thread2"); thread1->start(); thread2->start(); thread1->is_terminal_state().wait(); thread2->is_terminal_state().wait(); CU_ASSERT_TRUE_FATAL(thread1->is_check_passed().signalled()); CU_ASSERT_FALSE_FATAL(thread1->is_check_failed().signalled()); CU_ASSERT_TRUE_FATAL(thread2->is_check_passed().signalled()); CU_ASSERT_FALSE_FATAL(thread2->is_check_failed().signalled()); thread1->remove(); // implies stop() thread2->remove(); }
static int numLines( const char* const pathname) { FILE* stream = fopen(pathname, "r"); CU_ASSERT_PTR_NOT_NULL_FATAL(stream); int n = 0; char line[_POSIX_MAX_INPUT]; for (; fgets(line, sizeof(line), stream) != NULL; ++n) ; CU_ASSERT_TRUE_FATAL(feof(stream)); CU_ASSERT_FALSE_FATAL(ferror(stream)); CU_ASSERT_EQUAL_FATAL(fclose(stream), 0); return n; }
void testBuildQuery1() { CU_ASSERT_PTR_NOT_NULL_FATAL(jb); /* Query = { "name" : Петров Петр, "age" : 33, "family" : { "wife" : { "name" : "Jeniffer", "age" : {"$gt" : 25}, "phone" : "444-111" }, "children" : [ { "name" : "Dasha", "age" : {"$in" : [1, 4, 10]} } ] } */ bson q1; bson_init_as_query(&q1); bson_append_string(&q1, "name", "Петров Петр"); bson_append_int(&q1, "age", 33); bson q1family_wife; bson_init_as_query(&q1family_wife); bson_append_string(&q1family_wife, "name", "Jeniffer"); bson_append_start_object(&q1family_wife, "age"); bson_append_int(&q1family_wife, "$gt", 25); bson_append_finish_object(&q1family_wife); bson_append_string(&q1family_wife, "phone", "444-111"); bson_finish(&q1family_wife); bson q1family_child; bson_init_as_query(&q1family_child); bson_append_string(&q1family_child, "name", "Dasha"); //"age" : {"$in" : [1, 4, 10]} bson q1family_child_age_IN; bson_init_as_query(&q1family_child_age_IN); bson_append_start_array(&q1family_child_age_IN, "$in"); bson_append_int(&q1family_child_age_IN, "0", 1); bson_append_int(&q1family_child_age_IN, "1", 4); bson_append_int(&q1family_child_age_IN, "2", 10); bson_append_finish_array(&q1family_child_age_IN); bson_finish(&q1family_child_age_IN); bson_append_bson(&q1family_child, "age", &q1family_child_age_IN); bson_finish(&q1family_child); bson q1family; bson_init_as_query(&q1family); bson_append_bson(&q1family, "wife", &q1family_wife); bson_append_start_array(&q1family, "children"); bson_append_bson(&q1family, "0", &q1family_child); bson_append_finish_array(&q1family); bson_finish(&q1family); bson_append_bson(&q1, "family", &q1family); bson_finish(&q1); CU_ASSERT_FALSE_FATAL(q1.err); CU_ASSERT_FALSE_FATAL(q1family.err); CU_ASSERT_FALSE_FATAL(q1family_wife.err); CU_ASSERT_FALSE_FATAL(q1family_child.err); CU_ASSERT_FALSE_FATAL(q1family_child_age_IN.err); EJQ *ejq = ejdbcreatequery(jb, &q1, NULL, 0, NULL); CU_ASSERT_PTR_NOT_NULL_FATAL(ejq); bson_destroy(&q1); bson_destroy(&q1family); bson_destroy(&q1family_wife); bson_destroy(&q1family_child); bson_destroy(&q1family_child_age_IN); CU_ASSERT_PTR_NOT_NULL_FATAL(ejq->qobjlist); TCLIST *qmap = ejq->qobjlist; CU_ASSERT_EQUAL(qmap->num, 7); for (int i = 0; i < TCLISTNUM(qmap); ++i) { const EJQF *qf = TCLISTVALPTR(qmap, i); CU_ASSERT_PTR_NOT_NULL_FATAL(qf); const char* key = qf->fpath; switch (i) { case 0: { CU_ASSERT_STRING_EQUAL(key, "name"); CU_ASSERT_PTR_NOT_NULL(qf); CU_ASSERT_STRING_EQUAL(qf->expr, "Петров Петр"); CU_ASSERT_EQUAL(qf->tcop, TDBQCSTREQ); break; } case 1: { CU_ASSERT_STRING_EQUAL(key, "age"); CU_ASSERT_PTR_NOT_NULL(qf); CU_ASSERT_STRING_EQUAL(qf->expr, "33"); CU_ASSERT_EQUAL(qf->tcop, TDBQCNUMEQ); break; } case 2: { CU_ASSERT_STRING_EQUAL(key, "family.wife.name"); CU_ASSERT_PTR_NOT_NULL(qf); CU_ASSERT_STRING_EQUAL(qf->expr, "Jeniffer"); CU_ASSERT_EQUAL(qf->tcop, TDBQCSTREQ); break; } case 3: { CU_ASSERT_STRING_EQUAL(key, "family.wife.age"); CU_ASSERT_PTR_NOT_NULL(qf); CU_ASSERT_STRING_EQUAL(qf->expr, "25"); CU_ASSERT_EQUAL(qf->tcop, TDBQCNUMGT); break; } case 4: { CU_ASSERT_STRING_EQUAL(key, "family.wife.phone"); CU_ASSERT_PTR_NOT_NULL(qf); CU_ASSERT_STRING_EQUAL(qf->expr, "444-111"); CU_ASSERT_EQUAL(qf->tcop, TDBQCSTREQ); break; } case 5: { CU_ASSERT_STRING_EQUAL(key, "family.children.0.name"); CU_ASSERT_PTR_NOT_NULL(qf); CU_ASSERT_STRING_EQUAL(qf->expr, "Dasha"); CU_ASSERT_EQUAL(qf->tcop, TDBQCSTREQ); break; } case 6: { CU_ASSERT_STRING_EQUAL(key, "family.children.0.age"); CU_ASSERT_PTR_NOT_NULL(qf); CU_ASSERT_EQUAL(qf->ftype, BSON_ARRAY); TCLIST *al = tclistload(qf->expr, qf->exprsz); char* als = tcstrjoin(al, ','); CU_ASSERT_STRING_EQUAL(als, "1,4,10"); TCFREE(als); tclistdel(al); CU_ASSERT_EQUAL(qf->tcop, TDBQCNUMOREQ); break; } } } ejdbquerydel(ejq); }
void testCheckDuplicates(void) { bson bs, bs2; bson_iterator it; bson_type bt; bson_init(&bs); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "b", 2); bson_append_null(&bs, "c"); bson_append_start_object(&bs, "d"); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "e", 0); bson_append_int(&bs, "d", 1); bson_append_finish_object(&bs); bson_finish(&bs); CU_ASSERT_FALSE_FATAL(bs.err); CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs)); bson_destroy(&bs); bson_init(&bs); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "b", 2); bson_append_null(&bs, "c"); bson_append_start_object(&bs, "d"); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "e", 0); bson_append_int(&bs, "e", 1); bson_append_finish_object(&bs); bson_finish(&bs); CU_ASSERT_FALSE_FATAL(bs.err); CU_ASSERT_TRUE(bson_check_duplicate_keys(&bs)); bson_init(&bs2); bson_fix_duplicate_keys(&bs, &bs2); bson_finish(&bs2); CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs2)); BSON_ITERATOR_INIT(&it, &bs2); bt = bson_find_fieldpath_value("d.e", &it); CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt)); CU_ASSERT_EQUAL(bson_iterator_int(&it), 1); bson_destroy(&bs2); bson_init(&bs); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "b", 2); bson_append_null(&bs, "c"); bson_append_start_object(&bs, "d"); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "e", 0); bson_append_int(&bs, "d", 1); bson_append_finish_object(&bs); bson_append_start_array(&bs, "f"); bson_append_start_object(&bs, "0"); bson_append_string(&bs, "a", "a"); bson_append_string(&bs, "b", "b"); bson_append_int(&bs, "c", 1); bson_append_finish_object(&bs); bson_append_start_object(&bs, "1"); bson_append_string(&bs, "a", "a"); bson_append_string(&bs, "b", "b"); bson_append_int(&bs, "c", 1); bson_append_finish_object(&bs); bson_append_finish_array(&bs); bson_finish(&bs); CU_ASSERT_FALSE_FATAL(bs.err); CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs)); bson_init(&bs); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "b", 2); bson_append_null(&bs, "c"); bson_append_start_object(&bs, "d"); bson_append_string(&bs, "a", "a"); bson_append_int(&bs, "e", 0); bson_append_int(&bs, "d", 1); bson_append_start_object(&bs, "q"); bson_append_int(&bs, "w", 0); bson_append_finish_object(&bs); bson_append_finish_object(&bs); bson_append_start_array(&bs, "f"); bson_append_start_object(&bs, "0"); bson_append_string(&bs, "a", "a"); bson_append_string(&bs, "b", "b"); bson_append_int(&bs, "a", 1); bson_append_finish_object(&bs); bson_append_start_object(&bs, "1"); bson_append_string(&bs, "a", "a"); bson_append_string(&bs, "b", "b"); bson_append_int(&bs, "c", 1); bson_append_finish_object(&bs); bson_append_finish_array(&bs); bson_append_start_object(&bs, "a"); bson_append_finish_object(&bs); bson_append_start_object(&bs, "d"); bson_append_start_object(&bs, "q"); bson_append_int(&bs, "e", 1); bson_append_finish_object(&bs); bson_append_finish_object(&bs); bson_finish(&bs); CU_ASSERT_FALSE_FATAL(bs.err); CU_ASSERT_TRUE(bson_check_duplicate_keys(&bs)); bson_init(&bs2); bson_fix_duplicate_keys(&bs, &bs2); bson_finish(&bs2); CU_ASSERT_FALSE(bson_check_duplicate_keys(&bs2)); BSON_ITERATOR_INIT(&it, &bs2); bt = bson_find_fieldpath_value("f.0.a", &it); CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt)); CU_ASSERT_EQUAL(bson_iterator_int(&it), 1); BSON_ITERATOR_INIT(&it, &bs2); bt = bson_find_fieldpath_value("f.1.a", &it); CU_ASSERT_TRUE(BSON_IS_STRING_TYPE(bt)); CU_ASSERT_FALSE(strcmp(bson_iterator_string(&it), "a")); BSON_ITERATOR_INIT(&it, &bs2); bt = bson_find_fieldpath_value("a", &it); CU_ASSERT_EQUAL(bt, BSON_OBJECT); BSON_ITERATOR_INIT(&it, &bs2); bt = bson_find_fieldpath_value("d.q.w", &it); CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt)); CU_ASSERT_EQUAL(bson_iterator_int(&it), 0); BSON_ITERATOR_INIT(&it, &bs2); bt = bson_find_fieldpath_value("d.q.e", &it); CU_ASSERT_TRUE(BSON_IS_NUM_TYPE(bt)); CU_ASSERT_EQUAL(bson_iterator_int(&it), 1); }
void test_fill_binkeys(void) { const uint samples = 10000; typedef struct { uchar data[SHA_DIGEST_LENGTH] __attribute__((aligned(JUDY_key_size))); } _key_t __attribute__((aligned(JUDY_key_size))); unsigned int offset = 0xffff; uint *seen; Judy *j; JudySlot *slot; _key_t *keys; _key_t last; uint idx; j = judy_open_bin(sizeof(_key_t)); CU_ASSERT_PTR_NOT_NULL_FATAL(j); seen = malloc(samples*sizeof(uint)); CU_ASSERT_PTR_NOT_NULL_FATAL(seen); memset(seen, 0, samples*sizeof(uint)); keys = malloc(samples*sizeof(_key_t)); CU_ASSERT_PTR_NOT_NULL_FATAL(keys); memset(keys, 0, samples*sizeof(_key_t)); for (idx=0; idx<samples; ++idx) { unsigned char r[128]; unsigned char d[SHA_DIGEST_LENGTH]; CU_ASSERT_EQUAL(RAND_bytes(r, sizeof(r)), 1); SHA1(r, sizeof(r), d); memcpy(keys[idx].data, d, sizeof(keys[idx].data)); } CU_ASSERT_FALSE_FATAL(judy_key_bin(j, &last)); idx = 0; slot = judy_strt(j, NULL, 0); while (slot) { ++idx; slot = judy_nxt(j); } CU_ASSERT_EQUAL_FATAL(idx, 0); for (idx=0; idx<samples; ++idx) { slot = judy_slot_bin(j, keys[idx].data); CU_ASSERT_PTR_NULL_FATAL(slot); slot = judy_cell_bin(j, keys[idx].data); CU_ASSERT_PTR_NOT_NULL_FATAL(slot); *slot = idx + offset; slot = judy_slot_bin(j, keys[idx].data); CU_ASSERT_PTR_NOT_NULL_FATAL(slot); CU_ASSERT_EQUAL_FATAL(*slot, idx + offset); CU_ASSERT_TRUE_FATAL(judy_key_bin(j, &last)); CU_ASSERT_EQUAL_FATAL(memcmp(&keys[idx], &last, sizeof(_key_t)), 0); } for (idx=0; idx<samples; ++idx) { slot = judy_slot_bin(j, keys[idx].data); CU_ASSERT_PTR_NOT_NULL_FATAL(slot); CU_ASSERT_EQUAL_FATAL(*slot, idx + offset); CU_ASSERT_TRUE_FATAL(judy_key_bin(j, &last)); CU_ASSERT_EQUAL_FATAL(memcmp(&keys[idx], &last, sizeof(_key_t)), 0); } idx = 0; slot = judy_strt(j, NULL, 0); CU_ASSERT_PTR_NOT_NULL_FATAL(slot); while (slot) { ++idx; if (slot) { ++seen[*slot - offset]; CU_ASSERT_TRUE_FATAL(judy_key_bin(j, &last)); CU_ASSERT_EQUAL_FATAL(memcmp(&keys[*slot - offset], &last, sizeof(_key_t)), 0); } slot = judy_nxt(j); } CU_ASSERT_EQUAL_FATAL(idx, samples); for (idx=0; idx<samples; ++idx) { slot = judy_slot_bin(j, keys[idx].data); CU_ASSERT_PTR_NOT_NULL_FATAL(slot); CU_ASSERT_EQUAL_FATAL(*slot, idx + offset); CU_ASSERT_EQUAL_FATAL(seen[idx], 1); judy_del(j); slot = judy_slot_bin(j, keys[idx].data); CU_ASSERT_PTR_NULL_FATAL(slot); } for (idx=0; idx<samples; ++idx) { slot = judy_slot_bin(j, keys[idx].data); CU_ASSERT_PTR_NULL_FATAL(slot); } free(keys); free(seen); judy_close(j); }