int kvstore_del_simple(void) {
char *retval;
int ret;
ret = kvstore_put(&teststore, "key", "val");
ret += kvstore_get(&teststore, "key", &retval);
ASSERT_STRING_EQUAL(retval, "val");
free(retval);
ret += kvstore_del(&teststore, "key");
ASSERT_EQUAL(ret, 0);
retval = NULL;
ret = kvstore_get(&teststore, "key", &retval);
ASSERT_EQUAL(ret, ERRNOKEY);
ASSERT_PTR_NULL(retval);
return 1;
}
/* Attempts to get KEY from SERVER. Returns 0 if successful, else a negative
* error code. If successful, VALUE will point to a string which should later
* be free()d. */
int tpcfollower_get(tpcfollower_t *server, char *key, char *value) {
int ret;
if (strlen(key) > MAX_KEYLEN)
return ERR_KEYLEN;
ret = kvstore_get(&server->store, key, value);
return ret;
}
int kvstore_multiple_put_get(void) {
char *retval;
int ret;
ret = kvstore_put(&teststore, "KEY1", "VALUE1");
ret += kvstore_put(&teststore, "KEY2", "VALUE2");
ret += kvstore_put(&teststore, "KEY3", "VALUE3");
ret += kvstore_get(&teststore, "KEY1", &retval);
ASSERT_STRING_EQUAL(retval, "VALUE1");
free(retval);
ret += kvstore_get(&teststore, "KEY2", &retval);
ASSERT_STRING_EQUAL(retval, "VALUE2");
free(retval);
ret += kvstore_get(&teststore, "KEY3", &retval);
ASSERT_STRING_EQUAL(retval, "VALUE3");
free(retval);
ASSERT_EQUAL(ret, 0);
return 1;
}
int kvstore_get_no_key(void) {
char *retval = NULL;
int ret;
kvstore_test_init();
ret = kvstore_get(&teststore, "NONEXISTENT KEY", &retval);
ASSERT_EQUAL(ret, ERRNOKEY);
ASSERT_PTR_NULL(retval);
return 1;
}
int kvstore_get_put_uninitialized(void) {
char *retval;
int ret;
kvstore_clean(&teststore);
ret = kvstore_get(&teststore, "KEY", &retval);
ASSERT_EQUAL(ret, ERRFILACCESS);
ret = kvstore_put(&teststore, "KEY", "VALUE");
ASSERT_EQUAL(ret, ERRFILACCESS);
return 1;
}
int kvstore_put_get_blank_value(void) {
char *retval;
int ret;
ret = kvstore_put(&teststore, "valid key", "");
ret += kvstore_get(&teststore, "valid key", &retval);
ASSERT_STRING_EQUAL(retval, "");
ASSERT_EQUAL(ret, 0);
free(retval);
return 1;
}
int kvstore_single_put_get(void) {
char *retval;
int ret;
ret = kvstore_put(&teststore, "MYKEY", "MYVALUE");
ASSERT_EQUAL(ret, 0);
ret = kvstore_get(&teststore, "MYKEY", &retval);
ASSERT_EQUAL(ret, 0);
ASSERT_STRING_EQUAL(retval, "MYVALUE");
free(retval);
return 1;
}
int kvstore_get_oversized_key(void) {
char *retval = NULL, oversizedkey[MAX_KEYLEN + 2];
int ret, i;
strcpy(oversizedkey, "a");
for (i = 1; i < MAX_KEYLEN + 1; i++)
strcat(oversizedkey, "a");
ret = kvstore_get(&teststore, oversizedkey, &retval);
ASSERT_EQUAL(ret, ERRKEYLEN);
ASSERT_PTR_NULL(retval);
return 1;
}
int kvstore_put_overwrite(void) {
char *retval;
int ret;
ret = kvstore_put(&teststore, "mykey", "initial value");
ret += kvstore_put(&teststore, "mykey", "updated value");
ret += kvstore_get(&teststore, "mykey", &retval);
ASSERT_STRING_EQUAL(retval, "updated value");
free(retval);
ASSERT_EQUAL(ret, 0);
return 1;
}
static void
test_kvstore_del(void)
{
kvstore kvs;
char test_key[] = "hello";
char test_val[] = "world";
char *get_val = NULL;
CU_ASSERT_FATAL(NULL != (kvs = kvstore_new()));
CU_ASSERT(0 == kvstore_set(kvs, test_key, test_val));
get_val = kvstore_get(kvs, test_key);
CU_ASSERT(NULL != get_val);
CU_ASSERT(0 == strncmp(get_val, test_val, sizeof(test_val)));
CU_ASSERT(0 == kvstore_del(kvs, test_key));
get_val = kvstore_get(kvs, test_key);
CU_ASSERT(NULL == get_val);
CU_ASSERT(0 == kvstore_discard(kvs));
}
int kvstore_get_put_with_hash_conflicts(void) {
/* hash("abD") == hash("aae") == hash("ac#") */
char *retval, *key1 = "abD", *key2 = "aae", *key3 = "ac#";
int ret;
ret = kvstore_put(&teststore, key1, "value1");
ret += kvstore_put(&teststore, key2, "value2");
ret += kvstore_put(&teststore, key3, "value3");
ret += kvstore_get(&teststore, key1, &retval);
ASSERT_STRING_EQUAL(retval, "value1");
free(retval);
ret += kvstore_get(&teststore, key2, &retval);
ASSERT_STRING_EQUAL(retval, "value2");
free(retval);
ret += kvstore_get(&teststore, key3, &retval);
ASSERT_STRING_EQUAL(retval, "value3");
free(retval);
/* Clean the store and do it again in a different order to ensure that
the above success wasn't just because of a lucky ordering. */
kvstore_clean(&teststore);
kvstore_init(&teststore, KVSTORE_DIRNAME);
ret = kvstore_put(&teststore, key2, "value2");
ret += kvstore_put(&teststore, key3, "value3");
ret += kvstore_put(&teststore, key1, "value1");
ret += kvstore_get(&teststore, key1, &retval);
ASSERT_STRING_EQUAL(retval, "value1");
free(retval);
ret += kvstore_get(&teststore, key2, &retval);
ASSERT_STRING_EQUAL(retval, "value2");
free(retval);
ret += kvstore_get(&teststore, key3, &retval);
ASSERT_STRING_EQUAL(retval, "value3");
free(retval);
ASSERT_EQUAL(ret, 0);
return 1;
}
static void
test_kvstore_multikey(void)
{
kvstore kvs;
char key1[] = "key1";
char key2[] = "key2";
char key3[] = "key3";
char val1[] = "value1";
char val1a[] = "ohgodwhatsthis";
char val2[] = "value2";
char val3[] = "value3";
CU_ASSERT_FATAL(NULL != (kvs = kvstore_new()));
CU_ASSERT_FATAL(0 == kvstore_set(kvs, key1, val1));
CU_ASSERT_FATAL(0 == kvstore_set(kvs, key2, val2));
CU_ASSERT_FATAL(0 == kvstore_set(kvs, key3, val3));
CU_ASSERT(0 == strncmp(kvstore_get(kvs, key1), val1, MAX_WORD_LEN));
CU_ASSERT(0 == strncmp(kvstore_get(kvs, key2), val2, MAX_WORD_LEN));
CU_ASSERT(0 == strncmp(kvstore_get(kvs, key3), val3, MAX_WORD_LEN));
CU_ASSERT(0 == kvstore_set(kvs, key1, val1a));
CU_ASSERT(0 == strncmp(kvstore_get(kvs, key1), val1a, MAX_WORD_LEN));
CU_ASSERT(3 == kvstore_len(kvs));
CU_ASSERT(0 == kvstore_discard(kvs));
}
/* Attempts to get KEY from SERVER. Returns 0 if successful, else a negative
* error code. If successful, VALUE will point to a string which should later
* be free()d. If the KEY is in cache, take the value from there. Otherwise,
* go to the store and update the value in the cache. */
int kvserver_get(kvserver_t *server, char *key, char **value) {
// OUR CODE HERE
int ret;
pthread_rwlock_t *lock = kvcache_getlock(&server->cache, key);
if (lock == NULL) return ERRKEYLEN;
pthread_rwlock_rdlock(lock);
if (kvcache_get(&server->cache, key, value) == 0) {
pthread_rwlock_unlock(lock);
return 0;
}
pthread_rwlock_unlock(lock);
if ((ret = kvstore_get(&server->store, key, value)) < 0)
return ret;
pthread_rwlock_wrlock(lock);
ret = kvcache_put(&server->cache, key, *value); // what happens if this is unsuccessful?
pthread_rwlock_unlock(lock);
return ret;
}
int kvstore_del_hash_conflicts(void) {
/* hash("abD") == hash("aae") == hash("ac#") */
char *retval = NULL, *key1 = "abD", *key2 = "aae", *key3 = "ac#";
int ret;
ret = kvstore_put(&teststore, key1, "value1");
ret += kvstore_put(&teststore, key2, "value2");
ret += kvstore_put(&teststore, key3, "value3");
ret += kvstore_del(&teststore, key2);
ASSERT_EQUAL(ret, 0);
ret = kvstore_get(&teststore, key2, &retval);
ASSERT_PTR_NULL(retval);
ASSERT_EQUAL(ret, ERRNOKEY);
ret = kvstore_get(&teststore, key1, &retval);
ASSERT_STRING_EQUAL(retval, "value1");
free(retval);
ret += kvstore_get(&teststore, key3, &retval);
ASSERT_STRING_EQUAL(retval, "value3");
free(retval);
ASSERT_EQUAL(ret, 0);
/* Clean store and do operations again with a different insertion order to
* help ensure that success wasn't due to a lucky ordering. */
kvstore_clean(&teststore);
kvstore_init(&teststore, KVSTORE_DIRNAME);
ret = kvstore_put(&teststore, key2, "value2");
ret += kvstore_put(&teststore, key1, "value1");
ret += kvstore_put(&teststore, key3, "value3");
ret += kvstore_del(&teststore, key2);
ASSERT_EQUAL(ret, 0);
retval = NULL;
ret = kvstore_get(&teststore, key2, &retval);
ASSERT_PTR_NULL(retval);
ASSERT_EQUAL(ret, ERRNOKEY);
ret = kvstore_get(&teststore, key1, &retval);
ASSERT_STRING_EQUAL(retval, "value1");
free(retval);
ret += kvstore_get(&teststore, key3, &retval);
ASSERT_STRING_EQUAL(retval, "value3");
free(retval);
ASSERT_EQUAL(ret, 0);
return 1;
}
