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 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 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_rpush_lpop(int maxsize, 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);
unsigned char *testvalue;
long testvaluelen;
value[1] = 0;
int i;
RL_CALL_VERBOSE(create, RL_OK, db, key, keylen, maxsize, _commit, 0);
for (i = maxsize - 1; i >= 0; i--) {
value[0] = i % CHAR_MAX;
RL_CALL_VERBOSE(rl_pop, RL_OK, db, key, keylen, &testvalue, &testvaluelen, 1);
EXPECT_BYTES(value, 2, testvalue, testvaluelen);
rl_free(testvalue);
RL_BALANCED();
}
free(value);
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 basic_set_get()
{
int retval, i, j;
long size, size2, number;
unsigned char *data, *data2;
rlite *db = NULL;
RL_CALL_VERBOSE(rl_open, RL_OK, ":memory:", &db, RLITE_OPEN_READWRITE | RLITE_OPEN_CREATE);
for (i = 0; i < 2; i++) {
srand(1);
size = i == 0 ? 20 : 1020;
data = malloc(sizeof(unsigned char) * size);
for (j = 0; j < size; j++) {
data[j] = (unsigned char)(rand() / CHAR_MAX);
}
RL_CALL_VERBOSE(rl_multi_string_set, RL_OK, db, &number, data, size);
RL_CALL_VERBOSE(rl_multi_string_get, RL_OK, db, number, &data2, &size2);
EXPECT_BYTES(data, size, data2, size2);
rl_free(data);
rl_free(data2);
}
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 test_string()
{
INIT();
RL_CALL_VERBOSE(rl_set, RL_OK, db, key, keylen, UNSIGN("asd"), 3, 0, 0);
RL_CALL_VERBOSE(rl_dump, RL_OK, db, key, keylen, &testvalue, &testvaluelen);
EXPECT_BYTES(UNSIGN("\x00\x80\x00\x00\x00\x03\x61sd\x06\x00\xa4\xed\x80\xcb:7\x89\xd7"), 19, testvalue, testvaluelen);
rl_free(testvalue);
rl_close(db);
PASS();
}
TEST test_zset()
{
INIT();
RL_CALL_VERBOSE(rl_zadd, RL_OK, db, key, keylen, 1.23, UNSIGN("a"), 1);
RL_CALL_VERBOSE(rl_zadd, RL_OK, db, key, keylen, 4.5, UNSIGN("b"), 1);
RL_CALL_VERBOSE(rl_dump, RL_OK, db, key, keylen, &testvalue, &testvaluelen);
EXPECT_BYTES(UNSIGN("\x03\x80\x00\x00\x00\x02\x80\x00\x00\x00\x01\x61\x08\x31\x2e\x32\x33\x30\x30\x30\x30\x80\x00\x00\x00\x01\x62\x08\x34\x2e\x35\x30\x30\x30\x30\x30\x06\x00\x62\xf2\xc1\x8b\x73\x18\x51\xe6"), 46, testvalue, testvaluelen);
rl_free(testvalue);
rl_close(db);
PASS();
}
TEST test_hash()
{
INIT();
RL_CALL_VERBOSE(rl_hset, RL_OK, db, key, keylen, UNSIGN("field"), 5, UNSIGN("value"), 5, NULL, 0);
RL_CALL_VERBOSE(rl_hset, RL_OK, db, key, keylen, UNSIGN("field2"), 6, UNSIGN("value2"), 6, NULL, 0);
RL_CALL_VERBOSE(rl_dump, RL_OK, db, key, keylen, &testvalue, &testvaluelen);
EXPECT_BYTES(UNSIGN("\x04\x80\x00\x00\x00\x02\x80\x00\x00\x00\x05\x66\x69\x65\x6c\x64\x80\x00\x00\x00\x05\x76\x61\x6c\x75\x65\x80\x00\x00\x00\x06\x66\x69\x65\x6c\x64\x32\x80\x00\x00\x00\x06\x76\x61\x6c\x75\x65\x32\x06\x00\x74\xaf\xd2\x25\x1d\x50\x0c\xee"), 58, testvalue, testvaluelen);
rl_free(testvalue);
rl_close(db);
PASS();
}
TEST basic_test_sadd_smembers(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};
unsigned char *testdata;
long testdatalen;
int i;
rl_set_iterator *iterator;
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key, keylen, 2, datas, dataslen, NULL);
RL_BALANCED();
RL_CALL_VERBOSE(rl_smembers, RL_OK, db, &iterator, key, keylen);
i = 0;
while ((retval = rl_set_iterator_next(iterator, &testdata, &testdatalen)) == RL_OK) {
if (i++ == 1) {
EXPECT_BYTES(data, datalen, testdata, testdatalen);
} else {
EXPECT_BYTES(data2, data2len, testdata, testdatalen);
}
rl_free(testdata);
}
EXPECT_INT(retval, RL_END);
rl_close(db);
PASS();
}
TEST test_set()
{
INIT();
unsigned char *values[2] = {UNSIGN("b"), UNSIGN("a")};
long valueslen[2] = {1, 1};
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key, keylen, 2, values, valueslen, NULL);
RL_CALL_VERBOSE(rl_dump, RL_OK, db, key, keylen, &testvalue, &testvaluelen);
EXPECT_BYTES(UNSIGN("\x02\x80\x00\x00\x00\x02\x80\x00\x00\x00\x01\x61\x80\x00\x00\x00\x01\x62\x06\x00\xbb\x8c\x8c\xcf\x86{ \xfd"), 28, testvalue, testvaluelen);
rl_free(testvalue);
rl_close(db);
PASS();
}
TEST test_list()
{
INIT();
unsigned char *values[2] = {UNSIGN("b"), UNSIGN("a")};
long valueslen[2] = {1, 1};
RL_CALL_VERBOSE(rl_push, RL_OK, db, key, keylen, 1, 0, 2, values, valueslen, NULL);
RL_CALL_VERBOSE(rl_dump, RL_OK, db, key, keylen, &testvalue, &testvaluelen);
EXPECT_BYTES(UNSIGN("\x01\x80\x00\x00\x00\x02\x80\x00\x00\x00\x01\x62\x80\x00\x00\x00\x01\x61\x06\x00\x94\x46\xb5\x94\x1e\x1e_K"), 28, testvalue, testvaluelen);
rl_free(testvalue);
rl_close(db);
PASS();
}
TEST test_string()
{
int retval;
rlite *db = NULL;
unsigned char *key = UNSIGN("mykey"), *testvalue;
long keylen = 5, testvaluelen;
RL_CALL_VERBOSE(rl_open, RL_OK, ":memory:", &db, RLITE_OPEN_READWRITE | RLITE_OPEN_CREATE);
RL_CALL_VERBOSE(rl_set, RL_OK, db, key, keylen, UNSIGN("asd"), 3, 0, 0);
RL_CALL_VERBOSE(rl_dump, RL_OK, db, key, keylen, &testvalue, &testvaluelen);
EXPECT_BYTES(UNSIGN("\x00\x80\x00\x00\x00\x03\x61sd\x06\x00\xa4\xed\x80\xcb:7\x89\xd7"), 19, testvalue, testvaluelen);
rl_free(testvalue);
rl_close(db);
PASS();
}
TEST test_zset()
{
int retval;
rlite *db = NULL;
unsigned char *key = UNSIGN("mykey"), *testvalue;
long keylen = 5, testvaluelen;
RL_CALL_VERBOSE(rl_open, RL_OK, ":memory:", &db, RLITE_OPEN_READWRITE | RLITE_OPEN_CREATE);
RL_CALL_VERBOSE(rl_zadd, RL_OK, db, key, keylen, 1.23, UNSIGN("a"), 1);
RL_CALL_VERBOSE(rl_zadd, RL_OK, db, key, keylen, 4.5, UNSIGN("b"), 1);
RL_CALL_VERBOSE(rl_dump, RL_OK, db, key, keylen, &testvalue, &testvaluelen);
EXPECT_BYTES(UNSIGN("\x03\x80\x00\x00\x00\x02\x80\x00\x00\x00\x01\x61\x08\x31\x2e\x32\x33\x30\x30\x30\x30\x80\x00\x00\x00\x01\x62\x08\x34\x2e\x35\x30\x30\x30\x30\x30\x06\x00\x62\xf2\xc1\x8b\x73\x18\x51\xe6"), 46, testvalue, testvaluelen);
rl_free(testvalue);
rl_close(db);
PASS();
}
TEST test_hash()
{
int retval;
rlite *db = NULL;
unsigned char *key = UNSIGN("mykey"), *testvalue;
long keylen = 5, testvaluelen;
RL_CALL_VERBOSE(rl_open, RL_OK, ":memory:", &db, RLITE_OPEN_READWRITE | RLITE_OPEN_CREATE);
RL_CALL_VERBOSE(rl_hset, RL_OK, db, key, keylen, UNSIGN("field"), 5, UNSIGN("value"), 5, NULL, 0);
RL_CALL_VERBOSE(rl_hset, RL_OK, db, key, keylen, UNSIGN("field2"), 6, UNSIGN("value2"), 6, NULL, 0);
RL_CALL_VERBOSE(rl_dump, RL_OK, db, key, keylen, &testvalue, &testvaluelen);
EXPECT_BYTES(UNSIGN("\x04\x80\x00\x00\x00\x02\x80\x00\x00\x00\x05\x66\x69\x65\x6c\x64\x80\x00\x00\x00\x05\x76\x61\x6c\x75\x65\x80\x00\x00\x00\x06\x66\x69\x65\x6c\x64\x32\x80\x00\x00\x00\x06\x76\x61\x6c\x75\x65\x32\x06\x00\x74\xaf\xd2\x25\x1d\x50\x0c\xee"), 58, testvalue, testvaluelen);
rl_free(testvalue);
rl_close(db);
PASS();
}
TEST test_set()
{
int retval;
rlite *db = NULL;
unsigned char *key = UNSIGN("mykey"), *testvalue;
long keylen = 5, testvaluelen;
RL_CALL_VERBOSE(rl_open, RL_OK, ":memory:", &db, RLITE_OPEN_READWRITE | RLITE_OPEN_CREATE);
unsigned char *values[2] = {UNSIGN("b"), UNSIGN("a")};
long valueslen[2] = {1, 1};
RL_CALL_VERBOSE(rl_sadd, RL_OK, db, key, keylen, 2, values, valueslen, NULL);
RL_CALL_VERBOSE(rl_dump, RL_OK, db, key, keylen, &testvalue, &testvaluelen);
EXPECT_BYTES(UNSIGN("\x02\x80\x00\x00\x00\x02\x80\x00\x00\x00\x01\x61\x80\x00\x00\x00\x01\x62\x06\x00\xbb\x8c\x8c\xcf\x86{ \xfd"), 28, testvalue, testvaluelen);
rl_free(testvalue);
rl_close(db);
PASS();
}
TEST test_substr(long strsize, long start, long stop, long startindex, long expectedsize)
{
int retval;
unsigned char *data = malloc(sizeof(unsigned char) * strsize), *data2;
rlite *db = NULL;
RL_CALL_VERBOSE(rl_open, RL_OK, ":memory:", &db, RLITE_OPEN_READWRITE | RLITE_OPEN_CREATE);
long page, i, size2;
for (i = 0; i < strsize; i++) {
data[i] = i % 123;
}
RL_CALL_VERBOSE(rl_multi_string_set, RL_OK, db, &page, data, strsize);
RL_CALL_VERBOSE(rl_multi_string_getrange, RL_OK, db, page, &data2, &size2, start, stop);
EXPECT_BYTES(&data[startindex], size2, data2, expectedsize);
rl_free(data2);
free(data);
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 test_sha(long size)
{
int retval;
unsigned char *data = malloc(sizeof(unsigned char) * size);
rlite *db = NULL;
unsigned char digest1[20], digest2[20];
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;
}
RL_CALL_VERBOSE(rl_multi_string_set, RL_OK, db, &page, data, size);
RL_CALL_VERBOSE(rl_multi_string_sha1, RL_OK, db, digest1, page);
RL_CALL_VERBOSE(sha1, RL_OK, data, size, digest2);
EXPECT_BYTES(digest1, 20, digest2, 20);
rl_free(data);
rl_close(db);
PASS();
}
TEST do_string_test()
{
srand(1);
int retval;
rlite *db = NULL;
RL_CALL_VERBOSE(setup_db, RL_OK, &db, 0, 1);
unsigned char *data, *data2;
long number, i;
RL_CALL_VERBOSE(rl_string_create, RL_OK, db, &data, &number);
for (i = 0; i < db->page_size; i++) {
data[i] = (char)(rand() % CHAR_MAX);
}
RL_CALL_VERBOSE(rl_string_get, RL_OK, db, &data2, number);
EXPECT_BYTES(data, db->page_size, data2, db->page_size);
rl_close(db);
PASS();
}
TEST basic_test_lset(int maxsize, 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 *value = UNSIGN("my value"), *testvalue;
long valuelen = strlen((char *)value), testvaluelen;
RL_CALL_VERBOSE(create, RL_OK, db, key, keylen, maxsize, _commit, 1);
RL_CALL_VERBOSE(rl_lset, RL_INVALID_PARAMETERS, db, key, keylen, maxsize, value, valuelen);
RL_BALANCED();
RL_CALL_VERBOSE(rl_lset, RL_OK, db, key, keylen, -1, value, valuelen);
RL_BALANCED();
RL_CALL_VERBOSE(rl_lindex, RL_OK, db, key, keylen, -1, &testvalue, &testvaluelen);
EXPECT_BYTES(value, valuelen, testvalue, testvaluelen);
rl_free(testvalue);
rl_close(db);
PASS();
}
