int test_create()
{
bucket_ref bk = create_bucket();
if (bk.inst_ == 0 ) return 1;
destroy_bucket(&bk);
return 0;
}
int test_destroy()
{
bucket_ref bk = create_bucket();
assert (bk.inst_ != 0);
destroy_bucket(&bk);
return (bk.inst_ == 0 ) ? 0 : 1;
}
int test_size()
{
int result = 0;
bucket_ref bk = create_bucket();
assert (bk.inst_ != 0);
result = (0 == call(bk, size)) ? 0 : 1;
destroy_bucket(&bk);
assert (bk.inst_ == 0);
return result;
}
/// Add a key-value pair to a hash map.
bool DS_Hash_Map_add(DS_Hash_Map_t *map, char *key, void *value){
MU_ARG_CHECK(logger, false, map, key);
MU_COND_RWLOCK_WRLOCK(map->lock, logger);
char trunc_key[DS_HASH_MAP_KEY_SIZE + 1];
snprintf(trunc_key, DS_HASH_MAP_KEY_SIZE + 1, "%s", key);
size_t index = get_bucket_index(trunc_key, map->amount_of_buckets);
DS_Bucket_t *bucket = map->buckets[index];
if(!bucket){
bucket = (map->buckets[index] = create_bucket(trunc_key, value, NULL));
if(!bucket){
MU_LOG_ERROR(logger, "DS_Hash_Map_add->create_bucket: \"Was unable to create a bucket!\"");
MU_COND_RWLOCK_UNLOCK(map->lock, logger);
return false;
}
bucket->in_use = 1;
map->size++;
MU_COND_RWLOCK_UNLOCK(map->lock, logger);
return true;
}
void *key_exists = get_value_from_bucket(bucket, trunc_key);
if(key_exists){
MU_COND_RWLOCK_UNLOCK(map->lock, logger);
return false;
}
do {
if(!bucket->in_use){
sprintf(bucket->key, "%s", trunc_key);
bucket->value = value;
bucket->in_use = 1;
map->size++;
break;
} else if(!bucket->next){
bucket->next = create_bucket(trunc_key, value, NULL);
bucket->next->in_use = 1;
map->size++;
break;
}
} while((bucket = bucket->next));
MU_COND_RWLOCK_UNLOCK(map->lock, logger);
return true;
}
int test_append()
{
int result = 0;
bucket_ref bk = create_bucket();
assert (bk.inst_ != 0);
int value = 123;
call(bk, append, &value);
result = (1 == call(bk, size)) ? 0 : 1;
destroy_bucket(&bk);
assert (bk.inst_ == 0);
return result;
}
int test_append_cause_expand()
{
int result = 0;
bucket_ref bk = create_bucket();
assert (bk.inst_ != 0);
int value[5] = {0, 2, 4, 6, 8};
for (int i =0; i < 5; ++i)
call(bk, append, &value[i]);
result = (5 == call(bk, size)) ? 0 : 1;
destroy_bucket(&bk);
assert (bk.inst_ == 0);
return result;
}
int test_remove_keep_order()
{
int result = 0;
bucket_ref bk = create_bucket();
assert (bk.inst_ != 0);
int value[5] = {0, 2, 4, 6, 8};
for (int i =0; i < 5; ++i)
call(bk, append, &value[i]);
assert(5 == call(bk, size));
call(bk, remove_keep_order, 2);
assert(4 == call(bk, size));
result = (6 == *(int const*)call(bk, at, 2)) ? 0 : 1;
destroy_bucket(&bk);
assert (bk.inst_ == 0);
return result;
}
int test_remove_all()
{
int result = 0;
bucket_ref bk = create_bucket();
assert (bk.inst_ != 0);
int value[5] = {0, 2, 4, 6, 8};
for (int i =0; i < 5; ++i)
call(bk, append, &value[i]);
assert(5 == call(bk, size));
while(call(bk, size))
call(bk, remove, 0);
result = (0 == call(bk, size)) ? 0 : 1;
destroy_bucket(&bk);
assert (bk.inst_ == 0);
return result;
}
int main(int argc, char *argv[]) {
oss_media_init(AOS_LOG_INFO);
if (argc < 2) {
usage();
oss_media_destroy();
return -1;
}
if (strcmp("create_bucket", argv[1]) == 0) {
create_bucket();
}
else if (strcmp("delete_bucket", argv[1]) == 0) {
delete_bucket();
}
else if (strcmp("delete_file", argv[1]) == 0) {
delete_file();
}
else if (strcmp("list_files", argv[1]) == 0) {
list_files();
}
else if (strcmp("create_bucket_lifecycle", argv[1]) == 0) {
create_bucket_lifecycle();
}
else if (strcmp("get_bucket_lifecycle", argv[1]) == 0) {
get_bucket_lifecycle();
}
else if (strcmp("delete_bucket_lifecycle", argv[1]) == 0) {
delete_bucket_lifecycle();
}
else if (strcmp("get_token", argv[1]) == 0) {
get_token();
}
else if (strcmp("get_token_from_policy", argv[1]) == 0) {
get_token_from_policy();
}
else {
printf("Unsupport operation: %s\n", argv[1]);
usage();
}
oss_media_destroy();
return 0;
}
int test_at()
{
int result = 0;
bucket_ref bk = create_bucket();
assert (bk.inst_ != 0);
int value[5] = {0, 2, 4, 6, 8};
for (int i =0; i < 5; ++i)
call(bk, append, &value[i]);
assert(5 == call(bk, size));
for (int i =0; i < 5; ++i) {
if ( call(bk, at, i) != &(value[i]))
result = 1;
}
destroy_bucket(&bk);
assert (bk.inst_ == 0);
return result;
}
int test_traverse()
{
int result = 0;
bucket_ref bk = create_bucket();
assert (bk.inst_ != 0);
int value[5] = {0, 2, 4, 6, 8};
for (int i =0; i < 5; ++i)
call(bk, append, &value[i]);
assert(5 == call(bk, size));
for (int i =0; i < call(bk, size); ++i) {
int const* v = call(bk, at, i);
if( *v != value[i] )
result = 1;
}
destroy_bucket(&bk);
assert (bk.inst_ == 0);
return result;
}
int test_remove_in_traverse()
{
int result = 0;
bucket_ref bk = create_bucket();
assert (bk.inst_ != 0);
int value[7] = {9, 1, 2, 4, 6, 8, 7};
for (int i =0; i < 7; ++i)
call(bk, append, &value[i]);
assert(7 == call(bk, size));
for (size_t i =0 ; i < call(bk, size); ++i) {
int const *v = call(bk, at, i);
if (*v % 2) {
call(bk, remove, i);
i--;
}
}
result = (4 == call(bk, size)) ? 0 : 1;
destroy_bucket(&bk);
assert (bk.inst_ == 0);
return result;
}
/* Returning nullptr indicates no free entries left in the pool */
Element*
allocate(const T &st)
{
Element *return_value(nullptr);
PackedValuePoolBase::Slot slot;
if (m_free_slots.empty())
{
create_bucket();
}
FASTUIDRAWassert(!this->m_free_slots.empty());
slot = this->m_free_slots.back();
this->m_free_slots.pop_back();
Bucket &bucket(*m_data[slot.m_bucket]);
return_value = &bucket[slot.m_element_of_bucket];
return_value->initialize(st, slot, this);
FASTUIDRAWassert(return_value->ref_count() == 0);
return return_value;
}
