C++ rl_free函数代码示例

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 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 test_rlite_page_cache()
{
	rlite *db = malloc(sizeof(rlite));
	db->driver_type = RL_MEMORY_DRIVER;
	int retval;
	void *obj;

	int size = 15;
	db->write_pages_len = 0;
	db->read_pages = malloc(sizeof(rl_page *) * size);
	db->read_pages_len = size;
	db->read_pages_alloc = size;
	long i;
	for (i = 0; i < size; i++) {
		db->read_pages[i] = malloc(sizeof(rl_page));
		db->read_pages[i]->page_number = i;
		db->read_pages[i]->type = &rl_data_type_header;
		// not a real life scenario, we just need any pointer
		db->read_pages[i]->obj = db->read_pages[i];
	}
	for (i = 0; i < size; i++) {
		RL_CALL_VERBOSE(rl_read, RL_FOUND, db, &rl_data_type_header, i, NULL, &obj, 1);
		EXPECT_PTR(obj, db->read_pages[i])
	}
	for (i = 0; i < size; i++) {
		rl_free(db->read_pages[i]);
	}
	rl_free(db->read_pages);
	rl_free(db);
	PASS();
}

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();
}

int rl_close(rlite *db)
{
	if (!db) {
		return RL_OK;
	}

	if (db->driver_type == RL_FILE_DRIVER) {
		rl_unsubscribe_all(db);
	}
	// discard before removing the driver, since we need to release locks
	rl_discard(db);
	if (db->driver_type == RL_FILE_DRIVER) {
		rl_file_driver *driver = db->driver;
		rl_free(driver->filename);
	}
	else if (db->driver_type == RL_MEMORY_DRIVER) {
		rl_memory_driver* driver = db->driver;
		rl_free(driver->data);
	}
	if (db->subscriber_lock_filename) {
		remove(db->subscriber_lock_filename);
		rl_free(db->subscriber_lock_filename);
	}
	rl_free(db->driver);
	rl_free(db->subscriber_id);
	rl_free(db->read_pages);
	rl_free(db->write_pages);
	rl_free(db->databases);
	rl_free(db->initial_databases);
	rl_free(db);
	return RL_OK;
}

int rl_dirty_hash(struct rlite *db, unsigned char **hash)
{
	long i;
	int retval = RL_OK;
	rl_page *page;
	SHA1_CTX sha;
	unsigned char *data = NULL;

	if (db->write_pages_len == 0) {
		*hash = NULL;
		goto cleanup;
	}

	RL_MALLOC(data, db->page_size * sizeof(unsigned char));
	RL_MALLOC(*hash, sizeof(unsigned char) * 20);
	SHA1Init(&sha);
	for (i = 0; i < db->write_pages_len; i++) {
		page = db->write_pages[i];
		memset(data, 0, db->page_size);
		if (page->type) {
			retval = page->type->serialize(db, page->obj, data);
		}
		SHA1Update(&sha, data, db->page_size);
	}
	SHA1Final(*hash, &sha);
cleanup:
	rl_free(data);
	if (retval != RL_OK) {
		rl_free(*hash);
		*hash = NULL;
	}
	return retval;
}

int rl_key_set(rlite *db, const unsigned char *key, long keylen, unsigned char type, long value_page, unsigned long long expires, long version)
{
	int retval;

	rl_key *key_obj = NULL;
	unsigned char *digest = NULL;
	RL_CALL2(rl_key_delete, RL_OK, RL_NOT_FOUND, db, key, keylen);
	RL_MALLOC(digest, sizeof(unsigned char) * 20);
	RL_CALL(sha1, RL_OK, key, keylen, digest);
	rl_btree *btree;
	RL_CALL(rl_get_key_btree, RL_OK, db, &btree, 1);
	RL_MALLOC(key_obj, sizeof(*key_obj))
	RL_CALL(rl_multi_string_set, RL_OK, db, &key_obj->string_page, key, keylen);
	key_obj->type = type;
	key_obj->value_page = value_page;
	key_obj->expires = expires;
	// reserving version=0 for non existent keys
	if (version == 0) {
		version = 1;
	}
	key_obj->version = version;

	RL_CALL(rl_btree_add_element, RL_OK, db, btree, db->databases[rl_get_selected_db(db)], digest, key_obj);
	retval = RL_OK;
cleanup:
	if (retval != RL_OK) {
		rl_free(digest);
		rl_free(key_obj);
	}
	return retval;
}

int rl_header_deserialize(struct rlite *db, void **UNUSED(obj), void *UNUSED(context), unsigned char *data)
{
	int retval = RL_OK;
	int identifier_len = strlen((char *)identifier);
	if (memcmp(data, identifier, identifier_len) != 0) {
		fprintf(stderr, "Unexpected header, expecting %s\n", identifier);
		return RL_INVALID_STATE;
	}
	db->page_size = get_4bytes(&data[identifier_len]);
	db->initial_next_empty_page =
	db->next_empty_page = get_4bytes(&data[identifier_len + 4]);
	db->initial_number_of_pages =
	db->number_of_pages = get_4bytes(&data[identifier_len + 8]);
	db->initial_number_of_databases =
	db->number_of_databases = get_4bytes(&data[identifier_len + 12]);
	rl_free(db->databases);
	rl_free(db->initial_databases);
	RL_MALLOC(db->databases, sizeof(long) * (db->number_of_databases + RLITE_INTERNAL_DB_COUNT));
	RL_MALLOC(db->initial_databases, sizeof(long) * (db->number_of_databases + RLITE_INTERNAL_DB_COUNT));

	long i, pos = identifier_len + 16;
	for (i = 0; i < db->number_of_databases + RLITE_INTERNAL_DB_COUNT; i++) {
		db->initial_databases[i] =
		db->databases[i] = get_4bytes(&data[pos]);
		pos += 4;
	}
cleanup:
	return retval;
}

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_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();
}

static int add_member(rlite *db, rl_btree *scores, long scores_page, rl_skiplist *skiplist, long skiplist_page, double score, unsigned char *member, long memberlen)
{
	int retval;
	unsigned char *digest = NULL;
	void *value_ptr;
	RL_MALLOC(value_ptr, sizeof(double));
	digest = rl_malloc(sizeof(unsigned char) * 20);
	if (!digest) {
		rl_free(value_ptr);
		retval = RL_OUT_OF_MEMORY;
		goto cleanup;
	}
	*(double *)value_ptr = score;
	retval = sha1(member, memberlen, digest);
	if (retval != RL_OK) {
		rl_free(value_ptr);
		rl_free(digest);
		goto cleanup;
	}
	RL_CALL(rl_btree_add_element, RL_OK, db, scores, scores_page, digest, value_ptr);

	retval = rl_skiplist_add(db, skiplist, skiplist_page, score, member, memberlen);
	if (retval != RL_OK) {
		// This failure is critical. The btree already has the element, but
		// the skiplist failed to add it. If left as is, it would be in an
		// inconsistent state. Dropping all the transaction in progress.
		rl_discard(db);
		goto cleanup;
	}
cleanup:
	return retval;
}

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_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();
}

int rl_list_node_destroy(rlite *UNUSED(db), void *_node)
{
	rl_list_node *node = _node;
	long i;
	if (node->elements) {
		for (i = 0; i < node->size; i++) {
			rl_free(node->elements[i]);
		}
		rl_free(node->elements);
	}
	rl_free(node);
	return 0;
}

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();
}