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