TEST basic_test_ltrim(int _commit)
{
int retval;
unsigned char *key = UNSIGN("my key");
long keylen = strlen((char *)key);
long i, size;
unsigned char **values;
long *valueslen;
rlite *db = NULL;
RL_CALL_VERBOSE(setup_db, RL_OK, &db, _commit, 1);
RL_CALL_VERBOSE(create, RL_OK, db, key, keylen, 200, _commit, 1);
RL_CALL_VERBOSE(rl_ltrim, RL_OK, db, key, keylen, 50, -50);
RL_BALANCED();
RL_CALL_VERBOSE(rl_lrange, RL_OK, db, key, keylen, 0, -1, &size, &values, &valueslen);
EXPECT_LONG(size, 101);
for (i = 0; i < size; i++) {
EXPECT_LONG(valueslen[i], 2);
EXPECT_INT(values[i][0], ((50 + i) % CHAR_MAX));
EXPECT_INT(values[i][1], 0);
rl_free(values[i]);
}
rl_free(values);
rl_free(valueslen);
RL_CALL_VERBOSE(rl_ltrim, RL_DELETED, db, key, keylen, 1, 0);
RL_BALANCED();
rl_close(db);
PASS();
}
TEST test_append(long size, long append_size)
{
int retval;
unsigned char *data = malloc(sizeof(unsigned char) * size);
unsigned char *append_data = malloc(sizeof(unsigned char) * append_size);
unsigned char *testdata;
long testdatalen;
rlite *db = NULL;
RL_CALL_VERBOSE(rl_open, RL_OK, ":memory:", &db, RLITE_OPEN_READWRITE | RLITE_OPEN_CREATE);
long page, i;
for (i = 0; i < size; i++) {
data[i] = i % 123;
}
for (i = 0; i < append_size; i++) {
append_data[i] = i % 123;
}
RL_CALL_VERBOSE(rl_multi_string_set, RL_OK, db, &page, data, size);
RL_CALL_VERBOSE(rl_multi_string_append, RL_OK, db, page, append_data, append_size, &testdatalen);
EXPECT_LONG(testdatalen, size + append_size);
RL_CALL_VERBOSE(rl_multi_string_get, RL_OK, db, page, &testdata, &testdatalen);
EXPECT_LONG(testdatalen, size + append_size);
EXPECT_BYTES(testdata, size, data, size);
EXPECT_BYTES(&testdata[size], append_size, append_data, append_size);
rl_free(testdata);
rl_free(data);
rl_free(append_data);
rl_close(db);
PASS();
}
TEST basic_test_sadd_srem(int _commit)
{
int retval;
rlite *db = NULL;
RL_CALL_VERBOSE(setup_db, RL_OK, &db, _commit, 1);
unsigned char *key = UNSIGN("my key");
long keylen = strlen((char *)key);
unsigned char *data = UNSIGN("my data");
long datalen = strlen((char *)data);
unsigned char *data2 = UNSIGN("other data2");
long data2len = strlen((char *)data2);
unsigned char *datas[2] = {data, data2};
long dataslen[2] = {datalen, data2len};
long count;
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key, keylen, 2, datas, dataslen, NULL);
RL_BALANCED();
RL_CALL_VERBOSE(rl_srem, RL_OK, db, key, keylen, 1, datas, dataslen, &count);
RL_BALANCED();
EXPECT_LONG(count, 1);
RL_CALL_VERBOSE(rl_srem, RL_OK, db, key, keylen, 2, datas, dataslen, &count);
RL_BALANCED();
EXPECT_LONG(count, 1);
RL_CALL_VERBOSE(rl_key_get, RL_NOT_FOUND, db, key, keylen, NULL, NULL, NULL, NULL, NULL);
rl_close(db);
PASS();
}
TEST test_setrange(long initialsize, long index, long updatesize)
{
int retval;
long finalsize = index + updatesize > initialsize ? index + updatesize : initialsize;
long newlength, testdatalen;
unsigned char *testdata;
unsigned char *finaldata = calloc(finalsize, sizeof(unsigned char));
unsigned char *initialdata = malloc(sizeof(unsigned char) * initialsize);
unsigned char *updatedata = malloc(sizeof(unsigned char) * updatesize);
rlite *db = NULL;
RL_CALL_VERBOSE(rl_open, RL_OK, ":memory:", &db, RLITE_OPEN_READWRITE | RLITE_OPEN_CREATE);
long page, i;
for (i = 0; i < initialsize; i++) {
finaldata[i] = initialdata[i] = i % 123;
}
for (i = 0; i < updatesize; i++) {
finaldata[index + i] = updatedata[i] = i % 151;
}
RL_CALL_VERBOSE(rl_multi_string_set, RL_OK, db, &page, initialdata, initialsize);
RL_CALL_VERBOSE(rl_multi_string_setrange, RL_OK, db, page, updatedata, updatesize, index, &newlength);
EXPECT_LONG(finalsize, newlength);
RL_CALL_VERBOSE(rl_multi_string_get, RL_OK, db, page, &testdata, &testdatalen);
EXPECT_BYTES(finaldata, finalsize, testdata, testdatalen);
rl_free(testdata);
free(finaldata);
free(initialdata);
free(updatedata);
rl_close(db);
PASS();
}
TEST test_lrange(rlite *db, unsigned char *key, long keylen, long start, long stop, long cstart, long cstop)
{
unsigned char testvalue[2];
long testvaluelen = 2;
testvalue[1] = 0;
long i, size = 0, *valueslen = NULL;
unsigned char **values = NULL;
long pos;
int retval;
RL_CALL_VERBOSE(rl_lrange, RL_OK, db, key, keylen, start, stop, &size, &values, &valueslen);
EXPECT_LONG(size, cstop - cstart);
for (i = cstart; i < cstop; i++) {
testvalue[0] = i;
pos = i - cstart;
EXPECT_BYTES(values[pos], valueslen[pos], testvalue, testvaluelen);
}
for (i = 0; i < size; i++) {
rl_free(values[i]);
}
rl_free(values);
rl_free(valueslen);
PASS();
}
TEST sort_nosort_list_test(int _commit) {
int retval;
rlite *db = NULL;
RL_CALL_VERBOSE(setup_db, RL_OK, &db, _commit, 1);
unsigned char *key = (unsigned char *)"key";
long keylen = 3;
char *values[] = {"1", "0", "2"};
long valueslen[] = {1, 1, 1};
RL_CALL_VERBOSE(rl_push, RL_OK, db, key, keylen, 1, 0, 3, (unsigned char **)values, valueslen, NULL);
long objc;
unsigned char **objv;
long *objvlen;
RL_CALL_VERBOSE(rl_sort, RL_OK, db, key, keylen, NULL, 0, 1, 0, 0, 0, 0, -1, 0, NULL, NULL, NULL, 0, &objc, &objv, &objvlen);
EXPECT_LONG(objc, 3);
EXPECT_BYTES(objv[0], objvlen[0], "1", 1);
EXPECT_BYTES(objv[1], objvlen[1], "0", 1);
EXPECT_BYTES(objv[2], objvlen[2], "2", 1);
rl_free(objv[0]);
rl_free(objv[1]);
rl_free(objv[2]);
rl_free(objv);
rl_free(objvlen);
rl_close(db);
PASS();
}
TEST basic_test_lpushx(int _commit)
{
int retval;
rlite *db = NULL;
unsigned char *value = malloc(sizeof(unsigned char) * 2);
RL_CALL_VERBOSE(setup_db, RL_OK, &db, _commit, 1);
unsigned char *key = UNSIGN("my key");
long keylen = strlen((char *)key);
value[1] = 0;
long size;
RL_CALL_VERBOSE(rl_push, RL_NOT_FOUND, db, key, keylen, 0, 1, 1, &key, &keylen, NULL);
RL_CALL_VERBOSE(rl_llen, RL_NOT_FOUND, db, key, keylen, &size);
RL_CALL_VERBOSE(create, RL_OK, db, key, keylen, 1, _commit, 1);
RL_CALL_VERBOSE(rl_push, RL_OK, db, key, keylen, 0, 1, 1, &key, &keylen, NULL);
RL_CALL_VERBOSE(rl_llen, RL_OK, db, key, keylen, &size);
EXPECT_LONG(size, 2);
free(value);
rl_close(db);
PASS();
}
TEST sort_set_sortby_alpha_test(int _commit) {
int retval;
rlite *db = NULL;
RL_CALL_VERBOSE(setup_db, RL_OK, &db, _commit, 1);
unsigned char *key = (unsigned char *)"key";
long keylen = 3;
char *values[] = {"a", "s", "d"};
long valueslen[] = {1, 1, 1};
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key, keylen, 3, (unsigned char **)values, valueslen, NULL);
RL_CALL_VERBOSE(rl_set, RL_OK, db, (unsigned char *)"wa", 2, (unsigned char *)"1", 1, 1, 0);
RL_CALL_VERBOSE(rl_set, RL_OK, db, (unsigned char *)"ws", 2, (unsigned char *)"0", 1, 1, 0);
RL_CALL_VERBOSE(rl_set, RL_OK, db, (unsigned char *)"wd", 2, (unsigned char *)"2", 1, 1, 0);
long objc;
unsigned char **objv;
long *objvlen;
RL_CALL_VERBOSE(rl_sort, RL_OK, db, key, keylen, (unsigned char *)"w*", 2, 0, 0, 1, 0, 0, -1, 0, NULL, NULL, NULL, 0, &objc, &objv, &objvlen);
EXPECT_LONG(objc, 3);
EXPECT_BYTES(objv[0], objvlen[0], "s", 1);
EXPECT_BYTES(objv[1], objvlen[1], "a", 1);
EXPECT_BYTES(objv[2], objvlen[2], "d", 1);
rl_free(objv[0]);
rl_free(objv[1]);
rl_free(objv[2]);
rl_free(objv);
rl_free(objvlen);
rl_close(db);
PASS();
}
TEST basic_test_sadd_sunionstore(int _commit)
{
int retval;
rlite *db = NULL;
RL_CALL_VERBOSE(setup_db, RL_OK, &db, _commit, 1);
unsigned char *key = UNSIGN("my key");
long keylen = strlen((char *)key);
unsigned char *key2 = UNSIGN("my key2");
long key2len = strlen((char *)key2);
unsigned char *target = UNSIGN("my target");
long targetlen = strlen((char *)target);
unsigned char *datas[2] = {UNSIGN("my data"), UNSIGN("my data2")};
long dataslen[2] = {strlen((char *)datas[0]), strlen((char *)datas[1]) };
unsigned char *datas2[3] = {UNSIGN("other data2"), UNSIGN("yet another data"), UNSIGN("my data")};
long datas2len[3] = {strlen((char *)datas2[0]), strlen((char *)datas2[1]), strlen((char *)datas2[2])};
unsigned char *keys[2] = {key, key2};
long keyslen[2] = {keylen, key2len};
unsigned char **datasunion;
long *datasunionlen, datasc, i;
long added;
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key, keylen, 2, datas, dataslen, NULL);
RL_BALANCED();
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key2, key2len, 3, datas2, datas2len, NULL);
RL_BALANCED();
RL_CALL_VERBOSE(rl_sunionstore, RL_OK, db, target, targetlen, 2, keys, keyslen, &added);
EXPECT_LONG(added, 4);
datasc = added;
RL_CALL_VERBOSE(rl_srandmembers, RL_OK, db, target, targetlen, 0, &datasc, &datasunion, &datasunionlen);
#define ASSERT_IN_4(s, l)\
if (!IS_EQUAL(s, l, datasunion[0], datasunionlen[0]) &&\
!IS_EQUAL(s, l, datasunion[1], datasunionlen[1]) &&\
!IS_EQUAL(s, l, datasunion[2], datasunionlen[2]) &&\
!IS_EQUAL(s, l, datasunion[3], datasunionlen[3])\
) {\
fprintf(stderr, "Expected union to contains \"%s\" (%ld) on line %d\n", datas[0], dataslen[0], __LINE__);\
FAIL();\
}
ASSERT_IN_4(datas[0], dataslen[0]);
ASSERT_IN_4(datas[1], dataslen[1]);
ASSERT_IN_4(datas2[0], datas2len[0]);
ASSERT_IN_4(datas2[1], datas2len[1]);
for (i = 0; i < datasc; i++) {
rl_free(datasunion[i]);
}
rl_free(datasunion);
rl_free(datasunionlen);
rl_close(db);
PASS();
}
static int create(rlite *db, unsigned char *key, long keylen, int maxsize, int _commit, int left)
{
int i;
int retval;
long valuelen = 2, size;
unsigned char *value = malloc(sizeof(unsigned char) * 2);
value[1] = 0;
for (i = maxsize - 1; i >= 0; i--) {
value[0] = i % CHAR_MAX;
RL_CALL_VERBOSE(rl_push, RL_OK, db, key, keylen, 1, left, 1, &value, &valuelen, &size);
EXPECT_LONG(size, maxsize - i);
RL_BALANCED();
}
EXPECT_LONG(size, maxsize);
free(value);
return retval;
}
int test_hyperloglog_add_count()
{
int retval;
unsigned char *str = NULL;
long strlen = -1, card = -1;
unsigned char *argv[] = {UNSIGN("a"), UNSIGN("b"), UNSIGN("c")};
long argvlen[] = {1, 1, 1};
RL_CALL_VERBOSE(rl_str_pfadd, 1, NULL, 0, 3, argv, argvlen, &str, &strlen);
RL_CALL_VERBOSE(rl_str_pfcount, 0, 1, &str, &strlen, &card, NULL, NULL);
EXPECT_LONG(card, 3);
free(str);
PASS();
}
TEST basic_test_lpush_linsert(int _commit)
{
int retval;
rlite *db = NULL;
RL_CALL_VERBOSE(setup_db, RL_OK, &db, _commit, 1);
unsigned char *key = UNSIGN("my key");
long keylen = strlen((char *)key);
// note that LPUSH reverses the order
unsigned char *values[3] = {UNSIGN("CC"), UNSIGN("BB"), UNSIGN("AA")};
long valueslen[3] = {2, 2, 2};
long size;
unsigned char *testvalue;
long testvaluelen;
RL_CALL_VERBOSE(rl_push, RL_OK, db, key, keylen, 1, 1, 3, values, valueslen, NULL);
RL_BALANCED();
RL_CALL_VERBOSE(rl_linsert, RL_OK, db, key, keylen, 1, UNSIGN("AA"), 2, UNSIGN("AB"), 2, &size);
RL_BALANCED();
EXPECT_LONG(size, 4);
RL_CALL_VERBOSE(rl_lindex, RL_OK, db, key, keylen, 1, &testvalue, &testvaluelen);
EXPECT_STR("AB", testvalue, testvaluelen);
rl_free(testvalue);
RL_CALL_VERBOSE(rl_linsert, RL_NOT_FOUND, db, key, keylen, 1, UNSIGN("PP"), 2, UNSIGN("AB"), 2, NULL);
RL_BALANCED();
size = 0;
RL_CALL_VERBOSE(rl_llen, RL_OK, db, key, keylen, &size);
EXPECT_LONG(size, 4);
RL_CALL_VERBOSE(rl_linsert, RL_NOT_FOUND, db, UNSIGN("non existent key"), 10, 1, UNSIGN("PP"), 2, UNSIGN("AB"), 2, NULL);
rl_close(db);
PASS();
}
TEST basic_test_sadd_sunion(int _commit)
{
int retval;
rlite *db = NULL;
RL_CALL_VERBOSE(setup_db, RL_OK, &db, _commit, 1);
unsigned char *key = UNSIGN("my key");
long keylen = strlen((char *)key);
unsigned char *key2 = UNSIGN("my key2");
long key2len = strlen((char *)key2);
unsigned char *datas[2] = {UNSIGN("my data"), UNSIGN("my data2")};
long dataslen[2] = {strlen((char *)datas[0]), strlen((char *)datas[1]) };
unsigned char *datas2[3] = {UNSIGN("other data2"), UNSIGN("yet another data"), UNSIGN("my data")};
long datas2len[3] = {strlen((char *)datas2[0]), strlen((char *)datas2[1]), strlen((char *)datas2[2])};
unsigned char *keys[2] = {key, key2};
long keyslen[2] = {keylen, key2len};
unsigned char **datasunion;
long *datasunionlen, datasc, i;
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key, keylen, 2, datas, dataslen, NULL);
RL_BALANCED();
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key2, key2len, 3, datas2, datas2len, NULL);
RL_BALANCED();
RL_CALL_VERBOSE(rl_sunion, RL_OK, db, 2, keys, keyslen, &datasc, &datasunion, &datasunionlen);
EXPECT_LONG(datasc, 4);
EXPECT_BYTES(datas[1], dataslen[1], datasunion[0], datasunionlen[0]);
EXPECT_BYTES(datas[0], dataslen[0], datasunion[1], datasunionlen[1]);
EXPECT_BYTES(datas2[1], datas2len[1], datasunion[2], datasunionlen[2]);
EXPECT_BYTES(datas2[0], datas2len[0], datasunion[3], datasunionlen[3]);
for (i = 0; i < datasc; i++) {
rl_free(datasunion[i]);
}
rl_free(datasunion);
rl_free(datasunionlen);
rl_close(db);
PASS();
}
TEST basic_test_sadd_sunionstore_empty(int _commit)
{
int retval;
rlite *db = NULL;
RL_CALL_VERBOSE(setup_db, RL_OK, &db, _commit, 1);
unsigned char *key = UNSIGN("my key");
long keylen = strlen((char *)key);
unsigned char *key2 = UNSIGN("my key2");
long key2len = strlen((char *)key2);
long added;
RL_CALL_VERBOSE(rl_sunionstore, RL_OK, db, key, keylen, 1, &key2, &key2len, &added);
RL_BALANCED();
EXPECT_LONG(added, 0);
RL_CALL_VERBOSE(rl_key_get, RL_NOT_FOUND, db, key, keylen, NULL, NULL, NULL, NULL, NULL);
rl_close(db);
PASS();
}
TEST test_has_key()
{
rlite *db = NULL;
int retval;
const char *filepath = "rlite-test.rld";
if (access(filepath, F_OK) == 0) {
unlink(filepath);
}
RL_CALL_VERBOSE(rl_open, RL_OK, filepath, &db, RLITE_OPEN_CREATE | RLITE_OPEN_READWRITE);
unsigned char type = 'C', type2;
const unsigned char *key = (unsigned char *)"random key";
long keylen = strlen((char *) key);
long value = 529, value2;
RL_CALL_VERBOSE(rl_key_get, RL_NOT_FOUND, db, key, keylen, NULL, NULL, NULL, NULL, NULL);
RL_CALL_VERBOSE(rl_key_set, RL_OK, db, key, keylen, type, value, 0, 0);
RL_CALL_VERBOSE(rl_key_get, RL_FOUND, db, key, keylen, &type2, NULL, &value2, NULL, NULL);
EXPECT_LONG(value, value2);
EXPECT_INT(type, type2);
rl_close(db);
PASS();
}
TEST basic_test_sadd_sinter(int _commit)
{
int retval;
rlite *db = NULL;
RL_CALL_VERBOSE(setup_db, RL_OK, &db, _commit, 1);
unsigned char *key = UNSIGN("my key");
long keylen = strlen((char *)key);
unsigned char *key2 = UNSIGN("my key2");
long key2len = strlen((char *)key2);
unsigned char *data = UNSIGN("my data");
long datalen = strlen((char *)data);
unsigned char *data2 = UNSIGN("other data2");
long data2len = strlen((char *)data2);
unsigned char *keys[2] = {key, key2};
long keyslen[2] = {keylen, key2len};
unsigned char *datas[2] = {data, data2};
long dataslen[2] = {datalen, data2len};
unsigned char **datasdiff;
long *datasdifflen, datasc, i;
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key, keylen, 2, datas, dataslen, NULL);
RL_BALANCED();
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key2, key2len, 1, datas, dataslen, NULL);
RL_BALANCED();
RL_CALL_VERBOSE(rl_sinter, RL_OK, db, 2, keys, keyslen, &datasc, &datasdiff, &datasdifflen);
EXPECT_LONG(datasc, 1);
EXPECT_BYTES(data, datalen, datasdiff[0], datasdifflen[0]);
for (i = 0; i < datasc; i++) {
rl_free(datasdiff[i]);
}
rl_free(datasdiff);
rl_free(datasdifflen);
rl_close(db);
PASS();
}
TEST basic_test_sadd_sdiffstore(int _commit)
{
int retval;
rlite *db = NULL;
RL_CALL_VERBOSE(setup_db, RL_OK, &db, _commit, 1);
unsigned char *target = UNSIGN("my target");
long targetlen = strlen((char *)target);
unsigned char *key = UNSIGN("my key");
long keylen = strlen((char *)key);
unsigned char *key2 = UNSIGN("my key2");
long key2len = strlen((char *)key2);
unsigned char *data = UNSIGN("my data");
long datalen = strlen((char *)data);
unsigned char *data2 = UNSIGN("other data2");
long data2len = strlen((char *)data2);
unsigned char *keys[2] = {key, key2};
long keyslen[2] = {keylen, key2len};
unsigned char *datas[2] = {data, data2};
long dataslen[2] = {datalen, data2len};
unsigned char *datapop;
long datapoplen, size;
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key, keylen, 2, datas, dataslen, NULL);
RL_BALANCED();
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key2, key2len, 1, datas, dataslen, NULL);
RL_BALANCED();
RL_CALL_VERBOSE(rl_sdiffstore, RL_OK, db, target, targetlen, 2, keys, keyslen, &size);
RL_BALANCED();
EXPECT_LONG(size, 1);
RL_CALL_VERBOSE(rl_spop, RL_OK, db, target, targetlen, &datapop, &datapoplen);
EXPECT_BYTES(datapop, datapoplen, data2, data2len);
rl_free(datapop);
rl_close(db);
PASS();
}
TEST random_hash_test(long size, long btree_node_size)
{
INIT();
long *key, *val;
int *results = malloc(sizeof(int) * size);
long btree_page = db->next_empty_page;
RL_CALL_VERBOSE(rl_write, RL_OK, db, btree->type->btree_type, btree_page, btree);
long i;
for (i = 0; i < size; i++) {
results[i] = 0;
key = malloc(sizeof(long));
val = malloc(sizeof(long));
*key = i;
*val = i * 10;
RL_CALL_VERBOSE(rl_btree_add_element, RL_OK, db, btree, btree_page, key, val);
RL_CALL_VERBOSE(rl_btree_is_balanced, RL_OK, db, btree);
}
for (i = 0; i < size * 20; i++) {
RL_CALL_VERBOSE(rl_btree_random_element, RL_OK, db, btree, (void **)&key, (void **)&val);
EXPECT_LONG(10 * (*key), *val);
results[*key]++;
}
for (i = 0; i < size; i++) {
if (results[i] == 0) {
fprintf(stderr, "key %ld was not randomly returned\n", i);
retval = RL_UNEXPECTED;
goto cleanup;
}
}
retval = 0;
cleanup:
free(results);
rl_close(db);
if (retval == 0) { PASS(); } else { FAIL(); }
}
int test_hyperloglog_add_merge()
{
int retval;
unsigned char *str = NULL, *str2 = NULL, *str3;
long strlen = -1, strlen2, strlen3, card = -1;
unsigned char *argv[] = {UNSIGN("a"), UNSIGN("b"), UNSIGN("c")};
long argvlen[] = {1, 1, 1};
unsigned char *argv2[] = {UNSIGN("aa"), UNSIGN("ba"), UNSIGN("ca")};
long argvlen2[] = {2, 2, 2};
RL_CALL_VERBOSE(rl_str_pfadd, 1, NULL, 0, 3, argv, argvlen, &str, &strlen);
RL_CALL_VERBOSE(rl_str_pfadd, 1, NULL, 0, 3, argv2, argvlen2, &str2, &strlen2);
unsigned char *strs[] = {str, str2};
long strslen[] = {strlen, strlen2};
RL_CALL_VERBOSE(rl_str_pfmerge, 0, 2, strs, strslen, &str3, &strlen3);
RL_CALL_VERBOSE(rl_str_pfcount, 0, 1, &str3, &strlen3, &card, NULL, NULL);
EXPECT_LONG(card, 6);
free(str);
free(str2);
free(str3);
PASS();
}
TEST basic_insert_hash_test()
{
long btree_node_size = 2;
INIT();
long **keys = malloc(sizeof(long *) * 7);
long **vals = malloc(sizeof(long *) * 7);
long btree_page = db->next_empty_page;
RL_CALL_VERBOSE(rl_write, RL_OK, db, btree->type->btree_type, btree_page, btree);
long i;
for (i = 0; i < 7; i++) {
keys[i] = malloc(sizeof(long));
vals[i] = malloc(sizeof(long));
*keys[i] = i + 1;
*vals[i] = i * 10;
RL_CALL_VERBOSE(rl_btree_add_element, RL_OK, db, btree, btree_page, keys[i], vals[i]);
RL_CALL_VERBOSE(rl_btree_is_balanced, RL_OK, db, btree);
}
void *val;
for (i = 0; i < 7; i++) {
RL_CALL_VERBOSE(rl_btree_find_score, RL_FOUND, db, btree, keys[i], &val, NULL, NULL);
EXPECT_PTR(val, vals[i]);
EXPECT_LONG(*(long *)val, i * 10);
}
long nonexistent_vals[2] = {0, 8};
for (i = 0; i < 2; i++) {
RL_CALL_VERBOSE(rl_btree_find_score, RL_NOT_FOUND, db, btree, &nonexistent_vals[i], NULL, NULL, NULL);
}
retval = 0;
cleanup:
free(vals);
free(keys);
rl_close(db);
if (retval == 0) { PASS(); } else { FAIL(); }
}
TEST basic_test_lrem(int _commit)
{
int retval;
unsigned char *key = UNSIGN("my key");
long keylen = strlen((char *)key);
unsigned char *value1 = UNSIGN("AA"), *value2 = UNSIGN("BB");
long valuelen = 2, deleted;
long size;
unsigned char **values;
long *valueslen;
rlite *db = NULL;
RL_CALL_VERBOSE(setup_db, RL_OK, &db, _commit, 1);
long i, times = 100;
for (i = 0; i < times; i++) {
RL_CALL_VERBOSE(rl_push, RL_OK, db, key, keylen, 1, 1, 1, &value2, &valuelen, NULL);
RL_CALL_VERBOSE(rl_push, RL_OK, db, key, keylen, 1, 1, 1, &value1, &valuelen, NULL);
RL_BALANCED();
}
RL_CALL_VERBOSE(rl_lrem, RL_OK, db, key, keylen, 1, 2, value2, valuelen, &deleted);
RL_BALANCED();
EXPECT_LONG(deleted, 2);
#define TEST_VALUE(index, value)\
{\
unsigned char *testvalue;\
long testvaluelen;\
RL_CALL_VERBOSE(rl_lindex, RL_OK, db, key, keylen, index, &testvalue, &testvaluelen);\
if (testvaluelen != (long)strlen((char *)value) || memcmp(testvalue, value, testvaluelen) != 0) {\
FAIL();\
}\
rl_free(testvalue);\
}
TEST_VALUE(0, value1);
TEST_VALUE(1, value1);
TEST_VALUE(2, value1);
TEST_VALUE(3, value2);
TEST_VALUE(4, value1);
RL_CALL_VERBOSE(rl_lrem, RL_OK, db, key, keylen, -1, 200, value1, valuelen, &deleted);
RL_BALANCED();
EXPECT_LONG(deleted, 100);
RL_CALL_VERBOSE(rl_lrange, RL_OK, db, key, keylen, 0, -1, &size, &values, &valueslen);
for (i = 0; i < size; i++) {
EXPECT_STR("BB", values[i], valueslen[i]);
rl_free(values[i]);
}
rl_free(values);
rl_free(valueslen);
RL_CALL_VERBOSE(rl_lrem, RL_DELETED, db, key, keylen, 1, 0, value2, valuelen, &deleted);
EXPECT_LONG(deleted, 98);
RL_BALANCED();
RL_CALL_VERBOSE(rl_lrange, RL_NOT_FOUND, db, key, keylen, 0, -1, &size, &values, &valueslen);
rl_close(db);
PASS();
}
TEST fuzzy_test_srandmembers_unique(long size, int _commit)
{
int retval;
unsigned char **elements = malloc(sizeof(unsigned char *) * size);
long *elementslen = malloc(sizeof(long) * size);
int *results = malloc(sizeof(int) * size);
long i, j;
for (i = 0; i < size; i++) {
elementslen[i] = ((float)rand() / RAND_MAX) * 10 + 5;
elements[i] = malloc(sizeof(unsigned char) * elementslen[i]);
for (j = 0; j < elementslen[i]; j++) {
elements[i][j] = rand() % CHAR_MAX;
}
j++;
}
rlite *db = NULL;
RL_CALL_VERBOSE(setup_db, RL_OK, &db, _commit, 1);
unsigned char *key = UNSIGN("my key");
long keylen = strlen((char *)key);
long added;
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key, keylen, size, elements, elementslen, &added);
EXPECT_LONG(added, size);
RL_BALANCED();
long memberc = 1;
unsigned char **members = NULL;
long *memberslen = NULL;
RL_CALL_VERBOSE(rl_srandmembers, RL_OK, db, key, keylen, 0, &memberc, &members, &memberslen);
for (i = 0; i < memberc; i++) {
if (indexOf(size, elements, elementslen, members[i], memberslen[i]) == -1) {
fprintf(stderr, "randmembers result not found in elements, got 0x");
for (j = 0; j < memberslen[i]; j++) {
fprintf(stderr, "%2x", members[i][j]);
}
fprintf(stderr, " on line %d\n", __LINE__);
FAIL();
}
rl_free(members[i]);
}
rl_free(memberslen);
rl_free(members);
memberc = size * 2;
members = NULL;
memberslen = NULL;
RL_CALL_VERBOSE(rl_srandmembers, RL_OK, db, key, keylen, 0, &memberc, &members, &memberslen);
EXPECT_LONG(size, memberc);
for (i = 0; i < size; i++) {
results[i] = 0;
}
for (i = 0; i < memberc; i++) {
j = indexOf(size, elements, elementslen, members[i], memberslen[i]);
if (j == -1) {
fprintf(stderr, "randmembers result not found in elements, got 0x");
for (j = 0; j < memberslen[i]; j++) {
fprintf(stderr, "%2x", members[i][j]);
}
fprintf(stderr, " on line %d\n", __LINE__);
FAIL();
}
if (results[j] > 0) {
fprintf(stderr, "got repeated result on line %d\n", __LINE__);
FAIL();
}
results[j]++;
rl_free(members[i]);
}
rl_free(memberslen);
rl_free(members);
memberc = size * 2;
members = NULL;
memberslen = NULL;
RL_CALL_VERBOSE(rl_srandmembers, RL_OK, db, key, keylen, 1, &memberc, &members, &memberslen);
EXPECT_LONG(memberc, size * 2);
for (i = 0; i < size; i++) {
results[i] = 0;
}
for (i = 0; i < memberc; i++) {
j = indexOf(size, elements, elementslen, members[i], memberslen[i]);
if (j == -1) {
fprintf(stderr, "randmembers result not found in elements, got 0x");
for (j = 0; j < memberslen[i]; j++) {
fprintf(stderr, "%2x", members[i][j]);
}
fprintf(stderr, " on line %d\n", __LINE__);
FAIL();
}
results[j]++;
rl_free(members[i]);
}
rl_free(memberslen);
rl_free(members);
for (i = 0; i < size; i++) {
free(elements[i]);
}
free(elements);
free(results);
free(elementslen);
rl_close(db);
PASS();
}
TEST fuzzy_hash_test_iterator(long size, long btree_node_size, int _commit)
{
INIT();
rl_btree_iterator *iterator = NULL;
long *elements = malloc(sizeof(long) * size);
long *nonelements = malloc(sizeof(long) * size);
long *values = malloc(sizeof(long) * size);
long btree_page = db->next_empty_page;
RL_CALL_VERBOSE(rl_write, RL_OK, db, btree->type->btree_type, btree_page, btree);
long i, element, value, *element_copy, *value_copy;
long j;
void *tmp;
long prev_score = -1.0, score;
for (i = 0; i < size; i++) {
element = rand();
value = rand();
if (contains_element(element, elements, i)) {
i--;
continue;
}
else {
elements[i] = element;
element_copy = malloc(sizeof(long));
*element_copy = element;
values[i] = value;
value_copy = malloc(sizeof(long));
*value_copy = value;
RL_CALL_VERBOSE(rl_btree_add_element, RL_OK, db, btree, btree_page, element_copy, value_copy);
RL_CALL_VERBOSE(rl_btree_is_balanced, RL_OK, db, btree);
}
RL_CALL_VERBOSE(rl_btree_iterator_create, RL_OK, db, btree, &iterator);
EXPECT_LONG(iterator->size, i + 1);
j = 0;
while (RL_OK == (retval = rl_btree_iterator_next(iterator, &tmp, NULL))) {
score = *(long *)tmp;
rl_free(tmp);
if (j++ > 0) {
if (prev_score >= score) {
fprintf(stderr, "Tree is in a bad state in element %ld after adding child %ld\n", j, i);
retval = RL_UNEXPECTED;
goto cleanup;
}
}
prev_score = score;
}
if (retval != RL_END) {
rl_free(tmp);
goto cleanup;
}
EXPECT_LONG(j, i + 1);
iterator = NULL;
if (_commit) {
RL_CALL_VERBOSE(rl_commit, RL_OK, db);
RL_CALL_VERBOSE(rl_read, RL_FOUND, db, &rl_data_type_btree_hash_long_long, btree_page, &rl_btree_type_hash_long_long, &tmp, 1);
btree = tmp;
}
}
rl_btree_iterator_destroy(iterator);
retval = 0;
cleanup:
free(values);
free(elements);
free(nonelements);
rl_close(db);
if (retval == 0) { PASS(); } else { FAIL(); }
}
TEST fuzzy_hash_test(long size, long btree_node_size, int _commit)
{
INIT();
long *elements = malloc(sizeof(long) * size);
long *nonelements = malloc(sizeof(long) * size);
long *values = malloc(sizeof(long) * size);
void **flatten_scores = malloc(sizeof(void *) * size);
long btree_page = db->next_empty_page;
RL_CALL_VERBOSE(rl_write, RL_OK, db, btree->type->btree_type, btree_page, btree);
long i, element, value, *element_copy, *value_copy;
long j, flatten_size;
void *val, *tmp;
for (i = 0; i < size; i++) {
element = rand();
value = rand();
if (contains_element(element, elements, i)) {
i--;
continue;
}
else {
RL_CALL_VERBOSE(rl_read, RL_FOUND, db, &rl_data_type_btree_hash_long_long, btree_page, &rl_btree_type_hash_long_long, &tmp, 1);
elements[i] = element;
element_copy = malloc(sizeof(long));
*element_copy = element;
values[i] = value;
value_copy = malloc(sizeof(long));
*value_copy = value;
RL_CALL_VERBOSE(rl_btree_add_element, RL_OK, db, btree, btree_page, element_copy, value_copy);
RL_CALL_VERBOSE(rl_btree_is_balanced, RL_OK, db, btree);
}
flatten_size = 0;
RL_CALL_VERBOSE(rl_flatten_btree, RL_OK, db, btree, &flatten_scores, &flatten_size);
for (j = 1; j < flatten_size; j++) {
if (*(long *)flatten_scores[j - 1] >= *(long *)flatten_scores[j]) {
fprintf(stderr, "Tree is in a bad state in element %ld after adding child %ld\n", j, i);
retval = RL_UNEXPECTED;
goto cleanup;
}
}
if (_commit) {
RL_CALL_VERBOSE(rl_commit, RL_OK, db);
RL_CALL_VERBOSE(rl_read, RL_FOUND, db, &rl_data_type_btree_hash_long_long, btree_page, &rl_btree_type_hash_long_long, &tmp, 1);
btree = tmp;
}
}
for (i = 0; i < size; i++) {
element = rand();
if (contains_element(element, elements, size) || contains_element(element, nonelements, i)) {
i--;
}
else {
nonelements[i] = element;
}
}
for (i = 0; i < size; i++) {
RL_CALL_VERBOSE(rl_btree_find_score, RL_FOUND, db, btree, &elements[i], &val, NULL, NULL);
EXPECT_LONG(*(long *)val, values[i]);
RL_CALL_VERBOSE(rl_btree_find_score, RL_NOT_FOUND, db, btree, &nonelements[i], NULL, NULL, NULL);
}
retval = 0;
cleanup:
free(values);
free(elements);
free(nonelements);
free(flatten_scores);
rl_close(db);
if (retval == 0) { PASS(); } else { FAIL(); }
}
