mirror of
https://github.com/tezc/sc.git
synced 2025-02-04 07:13:10 +08:00
1552 lines
30 KiB
C
1552 lines
30 KiB
C
#include "sc_map.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
void example(void)
|
|
{
|
|
const char *key, *value;
|
|
struct sc_map_str map;
|
|
|
|
sc_map_init_str(&map, 0, 0);
|
|
|
|
sc_map_put_str(&map, "jack", "chicago");
|
|
sc_map_put_str(&map, "jane", "new york");
|
|
sc_map_put_str(&map, "janie", "atlanta");
|
|
|
|
sc_map_foreach (&map, key, value) {
|
|
printf("Key:[%s], Value:[%s] \n", key, value);
|
|
}
|
|
|
|
sc_map_term_str(&map);
|
|
}
|
|
|
|
void example_int_to_str()
|
|
{
|
|
uint32_t key;
|
|
const char *value;
|
|
struct sc_map_64s map;
|
|
|
|
sc_map_init_64s(&map, 0, 0);
|
|
|
|
sc_map_put_64s(&map, 100, "chicago");
|
|
sc_map_put_64s(&map, 200, "new york");
|
|
sc_map_put_64s(&map, 300, "atlanta");
|
|
|
|
value = sc_map_del_64s(&map, 100);
|
|
if (sc_map_found(&map)) {
|
|
printf("Deleted : %s \n", value);
|
|
}
|
|
|
|
sc_map_foreach (&map, key, value) {
|
|
printf("Key:[%d], Value:[%s] \n", key, value);
|
|
}
|
|
|
|
value = sc_map_del_64s(&map, 200);
|
|
if (sc_map_found(&map)) {
|
|
printf("Found : %s \n", value);
|
|
}
|
|
|
|
value = sc_map_put_64s(&map, 300, "los angeles");
|
|
if (sc_map_found(&map)) {
|
|
printf("overridden : %s \n", value);
|
|
}
|
|
|
|
sc_map_term_64s(&map);
|
|
}
|
|
|
|
static char *str_random(size_t size)
|
|
{
|
|
static char ch[] = "0123456789"
|
|
"abcdefghijklmnopqrstuvwxyz"
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
|
uint32_t index;
|
|
char *dest = malloc(size + 1);
|
|
|
|
for (size_t i = 0; i < size; ++i) {
|
|
index = (uint32_t) ((double) rand() / RAND_MAX *
|
|
(sizeof(ch) - 1));
|
|
dest[i] = ch[index];
|
|
}
|
|
|
|
dest[size - 1] = '\0';
|
|
|
|
return dest;
|
|
}
|
|
|
|
void test_32()
|
|
{
|
|
struct sc_map_32 map;
|
|
|
|
assert(sc_map_init_32(&map, 0, 0));
|
|
sc_map_term_32(&map);
|
|
assert(sc_map_init_32(&map, 0, 1) == false);
|
|
assert(sc_map_init_32(&map, 0, 99) == false);
|
|
|
|
assert(sc_map_init_32(&map, 16, 94));
|
|
|
|
sc_map_del_32(&map, 0);
|
|
assert(sc_map_found(&map) == false);
|
|
|
|
sc_map_del_32(&map, 1);
|
|
assert(sc_map_found(&map) == false);
|
|
|
|
for (int i = 0; i < 14; i++) {
|
|
sc_map_put_32(&map, i, i);
|
|
assert(!sc_map_oom(&map));
|
|
}
|
|
|
|
for (int i = 100; i < 200; i++) {
|
|
sc_map_del_32(&map, i);
|
|
assert(sc_map_found(&map) == false);
|
|
}
|
|
|
|
sc_map_clear_32(&map);
|
|
sc_map_clear_32(&map);
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_32(&map, i, i);
|
|
}
|
|
sc_map_put_32(&map, 31, 15);
|
|
sc_map_put_32(&map, 15, 15);
|
|
sc_map_put_32(&map, 46, 15);
|
|
|
|
sc_map_get_32(&map, 19);
|
|
assert(sc_map_found(&map) == false);
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_32(&map, (5 * i) + i, i);
|
|
}
|
|
|
|
sc_map_del_32(&map, 4);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_32(&map, 46);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_32(&map, 15);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_clear_32(&map);
|
|
for (int i = 1; i < 4; i++) {
|
|
sc_map_put_32(&map, 16 * i, i);
|
|
}
|
|
for (int i = 1; i < 4; i++) {
|
|
sc_map_put_32(&map, 1024 * i, i);
|
|
}
|
|
|
|
for (int i = 1; i < 4; i++) {
|
|
sc_map_put_32(&map, 512 * i, i);
|
|
}
|
|
|
|
sc_map_del_32(&map, 512);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_32(&map, 1024);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_32(&map, 48);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_term_32(&map);
|
|
}
|
|
|
|
void test_64()
|
|
{
|
|
struct sc_map_64 map;
|
|
|
|
assert(sc_map_init_64(&map, 0, 0));
|
|
sc_map_term_64(&map);
|
|
assert(sc_map_init_64(&map, 0, 1) == false);
|
|
assert(sc_map_init_64(&map, 0, 99) == false);
|
|
|
|
assert(sc_map_init_64(&map, 16, 94));
|
|
|
|
sc_map_del_64(&map, 0);
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_del_64(&map, 1);
|
|
assert(!sc_map_found(&map));
|
|
|
|
for (int i = 0; i < 14; i++) {
|
|
sc_map_put_64(&map, i, i);
|
|
}
|
|
|
|
for (int i = 100; i < 200; i++) {
|
|
sc_map_del_64(&map, i);
|
|
assert(!sc_map_found(&map));
|
|
}
|
|
|
|
sc_map_clear_64(&map);
|
|
sc_map_clear_64(&map);
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_64(&map, i, i);
|
|
}
|
|
sc_map_put_64(&map, 31, 15);
|
|
sc_map_put_64(&map, 15, 15);
|
|
sc_map_put_64(&map, 46, 15);
|
|
|
|
sc_map_get_64(&map, 19);
|
|
assert(!sc_map_found(&map));
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_64(&map, (5 * i) + i, i);
|
|
}
|
|
|
|
sc_map_del_64(&map, 4);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_64(&map, 46);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_64(&map, 15);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_clear_64(&map);
|
|
for (int i = 1; i < 4; i++) {
|
|
sc_map_put_64(&map, 16 * i, i);
|
|
}
|
|
for (int i = 1; i < 4; i++) {
|
|
sc_map_put_64(&map, 1024 * i, i);
|
|
}
|
|
|
|
for (int i = 1; i < 4; i++) {
|
|
sc_map_put_64(&map, 512 * i, i);
|
|
}
|
|
|
|
sc_map_del_64(&map, 512);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_64(&map, 1024);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_64(&map, 48);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_term_64(&map);
|
|
}
|
|
|
|
void test_64v()
|
|
{
|
|
struct sc_map_64v map;
|
|
|
|
assert(sc_map_init_64v(&map, 0, 0));
|
|
sc_map_term_64v(&map);
|
|
assert(sc_map_init_64v(&map, 0, 1) == false);
|
|
assert(sc_map_init_64v(&map, 0, 99) == false);
|
|
|
|
assert(sc_map_init_64v(&map, 16, 94));
|
|
sc_map_del_64v(&map, 0);
|
|
assert(sc_map_found(&map) == false);
|
|
|
|
sc_map_del_64v(&map, 1);
|
|
assert(sc_map_found(&map) == false);
|
|
|
|
for (int i = 0; i < 14; i++) {
|
|
sc_map_put_64v(&map, i, NULL);
|
|
}
|
|
|
|
for (int i = 100; i < 200; i++) {
|
|
sc_map_del_64v(&map, i);
|
|
assert(sc_map_found(&map) == false);
|
|
}
|
|
|
|
sc_map_clear_64v(&map);
|
|
sc_map_clear_64v(&map);
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_64v(&map, i, NULL);
|
|
assert(!sc_map_found(&map));
|
|
}
|
|
sc_map_put_64v(&map, 31, NULL);
|
|
sc_map_put_64v(&map, 15, NULL);
|
|
sc_map_put_64v(&map, 46, NULL);
|
|
|
|
sc_map_get_64v(&map, 19);
|
|
assert(sc_map_found(&map) == false);
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_64v(&map, (5 * i) + i, NULL);
|
|
}
|
|
|
|
sc_map_del_64v(&map, 4);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_64v(&map, 46);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_64v(&map, 15);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_clear_64v(&map);
|
|
for (int i = 1; i < 4; i++) {
|
|
sc_map_put_64v(&map, 16 * i, NULL);
|
|
}
|
|
for (int i = 1; i < 4; i++) {
|
|
sc_map_put_64v(&map, 1024 * i, NULL);
|
|
}
|
|
|
|
for (int i = 1; i < 4; i++) {
|
|
sc_map_put_64v(&map, 512 * i, NULL);
|
|
}
|
|
|
|
sc_map_del_64v(&map, 512);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_64v(&map, 1024);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_64v(&map, 48);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_term_64v(&map);
|
|
}
|
|
|
|
void test_64s()
|
|
{
|
|
struct sc_map_64s map;
|
|
|
|
assert(sc_map_init_64s(&map, 0, 0));
|
|
sc_map_term_64s(&map);
|
|
assert(sc_map_init_64s(&map, 0, 1) == false);
|
|
assert(sc_map_init_64s(&map, 0, 99) == false);
|
|
|
|
assert(sc_map_init_64s(&map, 16, 94));
|
|
sc_map_del_64s(&map, 0);
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_del_64s(&map, 1);
|
|
assert(!sc_map_found(&map));
|
|
|
|
for (int i = 0; i < 14; i++) {
|
|
sc_map_put_64s(&map, i, NULL);
|
|
}
|
|
|
|
for (int i = 100; i < 200; i++) {
|
|
sc_map_del_64s(&map, i);
|
|
assert(!sc_map_found(&map));
|
|
}
|
|
|
|
sc_map_clear_64s(&map);
|
|
sc_map_clear_64s(&map);
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_64s(&map, i, NULL);
|
|
}
|
|
sc_map_put_64s(&map, 31, NULL);
|
|
sc_map_put_64s(&map, 15, NULL);
|
|
sc_map_put_64s(&map, 46, NULL);
|
|
|
|
sc_map_get_64s(&map, 19);
|
|
assert(sc_map_found(&map) == false);
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_64s(&map, (5 * i) + i, NULL);
|
|
}
|
|
|
|
sc_map_del_64s(&map, 4);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_64s(&map, 46);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_64s(&map, 15);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_clear_64s(&map);
|
|
for (int i = 1; i < 4; i++) {
|
|
sc_map_put_64s(&map, 16 * i, NULL);
|
|
}
|
|
for (int i = 1; i < 4; i++) {
|
|
sc_map_put_64s(&map, 1024 * i, NULL);
|
|
}
|
|
|
|
for (int i = 1; i < 4; i++) {
|
|
sc_map_put_64s(&map, 512 * i, NULL);
|
|
}
|
|
|
|
sc_map_del_64s(&map, 512);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_64s(&map, 1024);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_64s(&map, 48);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_term_64s(&map);
|
|
}
|
|
|
|
void test_str()
|
|
{
|
|
const char *arr = "abcdefghijklmnoprstuvyzabcdefghijklmnoprstuvyzabcdef"
|
|
"ghijklmnoprstuvyz";
|
|
struct sc_map_str map;
|
|
|
|
assert(sc_map_init_str(&map, 0, 0));
|
|
sc_map_term_str(&map);
|
|
assert(sc_map_init_str(&map, 0, 1) == false);
|
|
assert(sc_map_init_str(&map, 0, 99) == false);
|
|
|
|
assert(sc_map_init_str(&map, 16, 94));
|
|
|
|
sc_map_del_str(&map, NULL);
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_del_str(&map, "");
|
|
assert(!sc_map_found(&map));
|
|
|
|
for (int i = 0; i < 14; i++) {
|
|
sc_map_put_str(&map, &arr[i], NULL);
|
|
}
|
|
|
|
for (int i = 15; i < 30; i++) {
|
|
sc_map_del_str(&map, &arr[i]);
|
|
assert(!sc_map_found(&map));
|
|
}
|
|
|
|
sc_map_clear_str(&map);
|
|
sc_map_clear_str(&map);
|
|
|
|
sc_map_put_str(&map, "h", NULL);
|
|
sc_map_put_str(&map, "z", NULL);
|
|
sc_map_get_str(&map, "13");
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_get_str(&map, NULL);
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_get_str(&map, "h");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_get_str(&map, "z");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_get_str(&map, "x");
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_put_str(&map, NULL, NULL);
|
|
|
|
sc_map_get_str(&map, NULL);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_str(&map, NULL);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_str(&map, "h");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_str(&map, "13");
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_clear_str(&map);
|
|
assert(sc_map_size_str(&map) == 0);
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_str(&map, &arr[i], NULL);
|
|
}
|
|
sc_map_put_str(&map, &arr[15], NULL);
|
|
sc_map_put_str(&map, &arr[7], NULL);
|
|
sc_map_put_str(&map, &arr[9], NULL);
|
|
|
|
sc_map_get_str(&map, &arr[16]);
|
|
assert(!sc_map_found(&map));
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_str(&map, &arr[(5 * i) + i], NULL);
|
|
}
|
|
|
|
sc_map_del_str(&map, &arr[4]);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_str(&map, &arr[6]);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_str(&map, &arr[15]);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_clear_str(&map);
|
|
sc_map_put_str(&map, "h", NULL);
|
|
sc_map_put_str(&map, "z", NULL);
|
|
sc_map_del_str(&map, "h");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_clear_str(&map);
|
|
|
|
sc_map_put_str(&map, "h", NULL);
|
|
sc_map_put_str(&map, "z", NULL);
|
|
sc_map_put_str(&map, "13", NULL);
|
|
sc_map_del_str(&map, "z");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_term_str(&map);
|
|
}
|
|
|
|
void test_sv()
|
|
{
|
|
const char *arr = "abcdefghijklmnoprstuvyzabcdefghijklmnoprstuvyzabcdef"
|
|
"ghijklmnoprstuvyz";
|
|
struct sc_map_sv map;
|
|
|
|
assert(sc_map_init_sv(&map, 0, 0));
|
|
sc_map_term_sv(&map);
|
|
assert(sc_map_init_sv(&map, 0, 1) == false);
|
|
assert(sc_map_init_sv(&map, 0, 99) == false);
|
|
|
|
assert(sc_map_init_sv(&map, 16, 94));
|
|
sc_map_del_sv(&map, NULL);
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_del_sv(&map, "");
|
|
assert(!sc_map_found(&map));
|
|
|
|
for (int i = 0; i < 14; i++) {
|
|
sc_map_put_sv(&map, &arr[i], NULL);
|
|
}
|
|
|
|
for (int i = 15; i < 30; i++) {
|
|
sc_map_del_sv(&map, &arr[i]);
|
|
assert(!sc_map_found(&map));
|
|
}
|
|
|
|
sc_map_clear_sv(&map);
|
|
sc_map_clear_sv(&map);
|
|
|
|
sc_map_put_sv(&map, "h", NULL);
|
|
sc_map_put_sv(&map, "z", NULL);
|
|
|
|
sc_map_get_sv(&map, "13");
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_get_sv(&map, NULL);
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_get_sv(&map, "h");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_get_sv(&map, "z");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_get_sv(&map, "x");
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_put_sv(&map, NULL, NULL);
|
|
sc_map_get_sv(&map, NULL);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_sv(&map, NULL);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_sv(&map, "h");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_sv(&map, "13");
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_clear_sv(&map);
|
|
assert(sc_map_size_sv(&map) == 0);
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_sv(&map, &arr[i], NULL);
|
|
}
|
|
sc_map_put_sv(&map, &arr[15], NULL);
|
|
sc_map_put_sv(&map, &arr[7], NULL);
|
|
sc_map_put_sv(&map, &arr[9], NULL);
|
|
|
|
sc_map_get_sv(&map, &arr[16]);
|
|
assert(!sc_map_found(&map));
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_sv(&map, &arr[(5 * i) + i], NULL);
|
|
}
|
|
|
|
sc_map_del_sv(&map, &arr[4]);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_sv(&map, &arr[6]);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_sv(&map, &arr[15]);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_clear_sv(&map);
|
|
sc_map_put_sv(&map, "h", NULL);
|
|
sc_map_put_sv(&map, "z", NULL);
|
|
sc_map_del_sv(&map, "h");
|
|
assert(sc_map_found(&map));
|
|
sc_map_clear_sv(&map);
|
|
|
|
sc_map_put_sv(&map, "h", NULL);
|
|
sc_map_put_sv(&map, "z", NULL);
|
|
sc_map_put_sv(&map, "13", NULL);
|
|
sc_map_del_sv(&map, "z");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_term_sv(&map);
|
|
}
|
|
|
|
void test_s64()
|
|
{
|
|
const char *arr = "abcdefghijklmnoprstuvyzabcdefghijklmnoprstuvyzabcdef"
|
|
"ghijklmnoprstuvyz";
|
|
struct sc_map_s64 map;
|
|
|
|
assert(sc_map_init_s64(&map, 0, 0));
|
|
sc_map_term_s64(&map);
|
|
assert(sc_map_init_s64(&map, 0, 1) == false);
|
|
assert(sc_map_init_s64(&map, 0, 99) == false);
|
|
|
|
assert(sc_map_init_s64(&map, 16, 94));
|
|
sc_map_del_s64(&map, NULL);
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_del_s64(&map, "");
|
|
assert(!sc_map_found(&map));
|
|
|
|
for (int i = 0; i < 14; i++) {
|
|
sc_map_put_s64(&map, &arr[i], 0);
|
|
}
|
|
|
|
for (int i = 15; i < 30; i++) {
|
|
sc_map_del_s64(&map, &arr[i]);
|
|
assert(!sc_map_found(&map));
|
|
}
|
|
|
|
sc_map_clear_s64(&map);
|
|
sc_map_clear_s64(&map);
|
|
|
|
sc_map_put_s64(&map, "h", 0);
|
|
sc_map_put_s64(&map, "z", 0);
|
|
|
|
sc_map_get_s64(&map, "13");
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_get_s64(&map, NULL);
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_get_s64(&map, "h");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_get_s64(&map, "z");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_get_s64(&map, "x");
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_put_s64(&map, NULL, 0);
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_get_s64(&map, NULL);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_s64(&map, NULL);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_s64(&map, "h");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_s64(&map, "13");
|
|
assert(!sc_map_found(&map));
|
|
sc_map_clear_s64(&map);
|
|
assert(sc_map_size_s64(&map) == 0);
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_s64(&map, &arr[i], 0);
|
|
}
|
|
sc_map_put_s64(&map, &arr[15], 0);
|
|
sc_map_put_s64(&map, &arr[7], 0);
|
|
sc_map_put_s64(&map, &arr[9], 0);
|
|
|
|
assert(!sc_map_oom(&map));
|
|
|
|
sc_map_get_s64(&map, &arr[16]);
|
|
assert(!sc_map_found(&map));
|
|
|
|
for (int i = 0; i < 5; i++) {
|
|
sc_map_put_s64(&map, &arr[(5 * i) + i], 0);
|
|
assert(!sc_map_oom(&map));
|
|
}
|
|
|
|
sc_map_del_s64(&map, &arr[4]);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_s64(&map, &arr[6]);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_del_s64(&map, &arr[15]);
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_clear_s64(&map);
|
|
sc_map_put_s64(&map, "h", 0);
|
|
sc_map_put_s64(&map, "z", 0);
|
|
sc_map_del_s64(&map, "h");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_clear_s64(&map);
|
|
|
|
sc_map_put_s64(&map, "h", 0);
|
|
sc_map_put_s64(&map, "z", 0);
|
|
sc_map_put_s64(&map, "13", 0);
|
|
sc_map_del_s64(&map, "z");
|
|
assert(sc_map_found(&map));
|
|
|
|
sc_map_term_s64(&map);
|
|
}
|
|
|
|
void test0()
|
|
{
|
|
uint64_t val;
|
|
struct sc_map_64 map;
|
|
|
|
sc_map_init_64(&map, 128, 0);
|
|
|
|
sc_map_put_64(&map, 100, 100);
|
|
assert(!sc_map_oom(&map));
|
|
assert(!sc_map_found(&map));
|
|
|
|
val = sc_map_get_64(&map, 100);
|
|
assert(val == 100);
|
|
assert(sc_map_found(&map));
|
|
|
|
val = sc_map_put_64(&map, 100, 200);
|
|
assert(sc_map_found(&map));
|
|
assert(val == 100);
|
|
|
|
val = sc_map_get_64(&map, 100);
|
|
assert(val == 200);
|
|
assert(sc_map_found(&map));
|
|
|
|
val = sc_map_del_64(&map, 100);
|
|
assert(sc_map_found(&map));
|
|
assert(val == 200);
|
|
|
|
val = sc_map_put_64(&map, 1, 1);
|
|
assert(!sc_map_found(&map));
|
|
val = sc_map_del_64(&map, 2);
|
|
assert(!sc_map_found(&map));
|
|
val = sc_map_get_64(&map, 1);
|
|
assert(sc_map_found(&map));
|
|
assert(val == 1);
|
|
val = sc_map_put_64(&map, 2, 2);
|
|
assert(!sc_map_found(&map));
|
|
|
|
val = sc_map_del_64(&map, 1);
|
|
assert(sc_map_found(&map));
|
|
assert(val == 1);
|
|
|
|
val = sc_map_del_64(&map, 2);
|
|
assert(sc_map_found(&map));
|
|
assert(val == 2);
|
|
|
|
sc_map_term_64(&map);
|
|
}
|
|
|
|
void test1()
|
|
{
|
|
struct sc_map_str map;
|
|
char *keys[128];
|
|
char *values[128];
|
|
const char *key, *value;
|
|
|
|
for (int i = 0; i < 128; i++) {
|
|
keys[i] = str_random((rand() % 64) + 32);
|
|
values[i] = str_random((rand() % 64) + 32);
|
|
}
|
|
|
|
sc_map_init_str(&map, 0, 0);
|
|
sc_map_put_str(&map, "100", "200");
|
|
value = sc_map_get_str(&map, "100");
|
|
assert(strcmp(value, "200") == 0);
|
|
sc_map_term_str(&map);
|
|
sc_map_put_str(&map, "100", "200");
|
|
value = sc_map_get_str(&map, "100");
|
|
assert(strcmp(value, "200") == 0);
|
|
sc_map_term_str(&map);
|
|
|
|
assert(!sc_map_init_str(&map, 0, -1));
|
|
assert(!sc_map_init_str(&map, 0, 24));
|
|
assert(!sc_map_init_str(&map, 0, 96));
|
|
assert(sc_map_init_str(&map, 0, 0));
|
|
assert(sc_map_size_str(&map) == 0);
|
|
sc_map_clear_str(&map);
|
|
assert(sc_map_size_str(&map) == 0);
|
|
sc_map_term_str(&map);
|
|
assert(sc_map_init_str(&map, 0, 0));
|
|
|
|
sc_map_foreach (&map, key, value) {
|
|
assert(false);
|
|
}
|
|
|
|
sc_map_foreach_key (&map, key) {
|
|
assert(false);
|
|
}
|
|
|
|
sc_map_foreach_value (&map, value) {
|
|
assert(false);
|
|
}
|
|
|
|
sc_map_put_str(&map, "key", "value");
|
|
sc_map_put_str(&map, "key", "value2");
|
|
|
|
value = sc_map_get_str(&map, "key");
|
|
assert(sc_map_found(&map));
|
|
assert(strcmp(value, "value2") == 0);
|
|
|
|
value = sc_map_del_str(&map, "key");
|
|
assert(sc_map_found(&map));
|
|
value = sc_map_get_str(&map, "key");
|
|
assert(!sc_map_found(&map));
|
|
sc_map_put_str(&map, "key", "value3");
|
|
value = sc_map_del_str(&map, "key");
|
|
assert(sc_map_found(&map));
|
|
assert(strcmp(value, "value3") == 0);
|
|
key = sc_map_del_str(&map, "key");
|
|
assert(!sc_map_found(&map));
|
|
|
|
sc_map_put_str(&map, "key", "value");
|
|
assert(sc_map_size_str(&map) == 1);
|
|
sc_map_put_str(&map, NULL, "nullvalue");
|
|
assert(sc_map_size_str(&map) == 2);
|
|
value = sc_map_get_str(&map, NULL);
|
|
assert(sc_map_found(&map));
|
|
assert(strcmp(value, "nullvalue") == 0);
|
|
sc_map_del_str(&map, NULL);
|
|
assert(sc_map_found(&map));
|
|
assert(sc_map_size_str(&map) == 1);
|
|
|
|
sc_map_clear_str(&map);
|
|
assert(sc_map_size_str(&map) == 0);
|
|
|
|
for (int i = 0; i < 100; i++) {
|
|
sc_map_put_str(&map, keys[i], values[i]);
|
|
}
|
|
|
|
for (int i = 0; i < 100; i++) {
|
|
value = sc_map_get_str(&map, keys[i]);
|
|
assert(sc_map_found(&map));
|
|
assert(strcmp(value, values[i]) == 0);
|
|
}
|
|
|
|
sc_map_put_str(&map, keys[0], values[101]);
|
|
assert(sc_map_size_str(&map) == 100);
|
|
sc_map_put_str(&map, keys[101], values[102]);
|
|
assert(sc_map_size_str(&map) == 101);
|
|
sc_map_clear_str(&map);
|
|
assert(sc_map_size_str(&map) == 0);
|
|
|
|
for (int i = 0; i < 100; i++) {
|
|
sc_map_put_str(&map, keys[i], values[i]);
|
|
}
|
|
|
|
for (int i = 0; i < 100; i++) {
|
|
value = sc_map_get_str(&map, keys[i]);
|
|
assert(sc_map_found(&map));
|
|
assert(strcmp(value, values[i]) == 0);
|
|
}
|
|
|
|
sc_map_term_str(&map);
|
|
|
|
assert(sc_map_init_str(&map, 0, 0));
|
|
for (int i = 0; i < 100; i++) {
|
|
sc_map_put_str(&map, keys[i], values[i]);
|
|
}
|
|
|
|
bool found;
|
|
sc_map_foreach (&map, key, value) {
|
|
found = false;
|
|
for (int j = 0; j < 100; j++) {
|
|
if (strcmp(key, keys[j]) == 0 &&
|
|
strcmp(value, values[j]) == 0) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
assert(found);
|
|
}
|
|
|
|
sc_map_foreach_key (&map, key) {
|
|
found = false;
|
|
for (int j = 0; j < 100; j++) {
|
|
if (strcmp(key, keys[j]) == 0) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
assert(found);
|
|
}
|
|
|
|
sc_map_foreach_value (&map, value) {
|
|
found = false;
|
|
for (int j = 0; j < 100; j++) {
|
|
if (strcmp(value, values[j]) == 0) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
assert(found);
|
|
}
|
|
|
|
sc_map_term_str(&map);
|
|
for (int i = 0; i < 128; i++) {
|
|
free(keys[i]);
|
|
free(values[i]);
|
|
}
|
|
}
|
|
|
|
void test2()
|
|
{
|
|
struct sc_map_32 map;
|
|
uint32_t keys[128];
|
|
uint32_t values[128];
|
|
uint32_t key, value;
|
|
uint32_t random;
|
|
|
|
for (int i = 0; i < 128; i++) {
|
|
retry:
|
|
random = (uint32_t) rand();
|
|
for (int j = 0; j < i; j++) {
|
|
if (keys[j] == random) {
|
|
goto retry;
|
|
}
|
|
}
|
|
|
|
keys[i] = random;
|
|
values[i] = rand();
|
|
}
|
|
|
|
assert(sc_map_init_32(&map, 16, 50));
|
|
assert(sc_map_size_32(&map) == 0);
|
|
sc_map_put_32(&map, 0, 0);
|
|
sc_map_clear_32(&map);
|
|
assert(sc_map_size_32(&map) == 0);
|
|
|
|
for (int i = 0; i < 100; i++) {
|
|
sc_map_put_32(&map, keys[i], values[i]);
|
|
value = sc_map_get_32(&map, keys[i]);
|
|
assert(sc_map_found(&map));
|
|
assert(value == values[i]);
|
|
sc_map_put_32(&map, keys[i], values[i]);
|
|
|
|
value = sc_map_del_32(&map, keys[i]);
|
|
assert(sc_map_found(&map));
|
|
assert(value == values[i]);
|
|
}
|
|
|
|
for (int i = 0; i < 128; i++) {
|
|
sc_map_put_32(&map, keys[i], values[i]);
|
|
}
|
|
|
|
assert(sc_map_size_32(&map) == 128);
|
|
|
|
bool found;
|
|
sc_map_foreach (&map, key, value) {
|
|
found = false;
|
|
for (int j = 0; j < 128; j++) {
|
|
if (key == keys[j] && value == values[j]) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
assert(found);
|
|
}
|
|
|
|
sc_map_foreach_key (&map, key) {
|
|
found = false;
|
|
for (int j = 0; j < 128; j++) {
|
|
if (key == keys[j]) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
assert(found);
|
|
}
|
|
|
|
sc_map_foreach_value (&map, value) {
|
|
found = false;
|
|
for (int j = 0; j < 128; j++) {
|
|
if (value == values[j]) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
assert(found);
|
|
}
|
|
|
|
sc_map_term_32(&map);
|
|
}
|
|
|
|
void test3()
|
|
{
|
|
struct sc_map_64 map;
|
|
uint64_t keys[128];
|
|
uint64_t values[128];
|
|
uint64_t key, value;
|
|
uint32_t random;
|
|
|
|
for (int i = 0; i < 128; i++) {
|
|
retry:
|
|
random = (uint32_t) rand();
|
|
for (int j = 0; j < i; j++) {
|
|
if (keys[j] == random) {
|
|
goto retry;
|
|
}
|
|
}
|
|
|
|
keys[i] = random;
|
|
values[i] = rand();
|
|
}
|
|
|
|
assert(sc_map_init_64(&map, 16, 50));
|
|
assert(sc_map_size_64(&map) == 0);
|
|
sc_map_put_64(&map, 0, 0);
|
|
sc_map_clear_64(&map);
|
|
assert(sc_map_size_64(&map) == 0);
|
|
|
|
for (int i = 0; i < 100; i++) {
|
|
sc_map_put_64(&map, keys[i], values[i]);
|
|
value = sc_map_get_64(&map, keys[i]);
|
|
assert(sc_map_found(&map));
|
|
assert(value == values[i]);
|
|
|
|
sc_map_put_64(&map, keys[i], values[i]);
|
|
value = sc_map_del_64(&map, keys[i]);
|
|
assert(sc_map_found(&map));
|
|
assert(value == values[i]);
|
|
}
|
|
|
|
for (int i = 0; i < 128; i++) {
|
|
sc_map_put_64(&map, keys[i], values[i]);
|
|
}
|
|
|
|
assert(sc_map_size_64(&map) == 128);
|
|
|
|
bool found;
|
|
sc_map_foreach (&map, key, value) {
|
|
found = false;
|
|
for (int j = 0; j < 128; j++) {
|
|
if (key == keys[j] && value == values[j]) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
assert(found);
|
|
}
|
|
|
|
sc_map_foreach_key (&map, key) {
|
|
found = false;
|
|
for (int j = 0; j < 128; j++) {
|
|
if (key == keys[j]) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
assert(found);
|
|
}
|
|
|
|
sc_map_foreach_value (&map, value) {
|
|
found = false;
|
|
for (int j = 0; j < 128; j++) {
|
|
if (value == values[j]) {
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
assert(found);
|
|
}
|
|
|
|
sc_map_term_64(&map);
|
|
}
|
|
|
|
void test4()
|
|
{
|
|
const char *c;
|
|
struct sc_map_64s map64s;
|
|
|
|
assert(sc_map_init_64s(&map64s, 1, 87));
|
|
for (int i = 0; i < 100; i++) {
|
|
sc_map_put_64s(&map64s, i, NULL);
|
|
c = sc_map_get_64s(&map64s, i);
|
|
assert(sc_map_found(&map64s));
|
|
assert(c == NULL);
|
|
}
|
|
assert(sc_map_size_64s(&map64s) == 100);
|
|
for (int i = 0; i < 100; i++) {
|
|
c = sc_map_del_64s(&map64s, i);
|
|
assert(sc_map_found(&map64s));
|
|
assert(c == NULL);
|
|
}
|
|
assert(sc_map_size_64s(&map64s) == 0);
|
|
sc_map_put_64s(&map64s, 3, NULL);
|
|
assert(sc_map_size_64s(&map64s) == 1);
|
|
sc_map_clear_64s(&map64s);
|
|
assert(sc_map_size_64s(&map64s) == 0);
|
|
|
|
sc_map_term_64s(&map64s);
|
|
|
|
const char *v;
|
|
struct sc_map_64v map64v;
|
|
|
|
assert(sc_map_init_64v(&map64v, 1, 87));
|
|
for (int i = 0; i < 100; i++) {
|
|
sc_map_put_64v(&map64v, i, NULL);
|
|
v = sc_map_get_64v(&map64v, i);
|
|
assert(sc_map_found(&map64v));
|
|
assert(v == NULL);
|
|
}
|
|
assert(sc_map_size_64v(&map64v) == 100);
|
|
for (int i = 0; i < 100; i++) {
|
|
v = sc_map_del_64v(&map64v, i);
|
|
assert(sc_map_found(&map64v));
|
|
assert(v == NULL);
|
|
}
|
|
assert(sc_map_size_64v(&map64v) == 0);
|
|
sc_map_put_64v(&map64v, 3, NULL);
|
|
assert(sc_map_size_64v(&map64v) == 1);
|
|
sc_map_clear_64v(&map64v);
|
|
assert(sc_map_size_64v(&map64v) == 0);
|
|
|
|
sc_map_term_64v(&map64v);
|
|
|
|
char *keys[128];
|
|
char *values[128];
|
|
|
|
for (int i = 0; i < 128; i++) {
|
|
keys[i] = str_random((rand() % 64) + 32);
|
|
values[i] = str_random((rand() % 64) + 32);
|
|
}
|
|
|
|
struct sc_map_str mapstr;
|
|
assert(sc_map_init_str(&mapstr, 0, 26));
|
|
for (int i = 0; i < 64; i++) {
|
|
sc_map_put_str(&mapstr, keys[i], (void *) (uintptr_t) i);
|
|
}
|
|
|
|
v = sc_map_get_str(&mapstr, keys[0]);
|
|
assert(sc_map_found(&mapstr));
|
|
assert(v == 0);
|
|
assert(sc_map_size_str(&mapstr) == 64);
|
|
|
|
v = sc_map_del_str(&mapstr, keys[12]);
|
|
assert(sc_map_found(&mapstr));
|
|
assert(v == (void *) 12);
|
|
assert(sc_map_size_str(&mapstr) == 63);
|
|
sc_map_clear_str(&mapstr);
|
|
sc_map_term_str(&mapstr);
|
|
|
|
struct sc_map_sv mapsv;
|
|
assert(sc_map_init_sv(&mapsv, 0, 26));
|
|
for (int i = 0; i < 64; i++) {
|
|
sc_map_put_sv(&mapsv, keys[i], (void *) (uintptr_t) i);
|
|
}
|
|
v = sc_map_get_sv(&mapsv, keys[0]);
|
|
assert(sc_map_found(&mapsv));
|
|
assert(v == 0);
|
|
assert(sc_map_size_sv(&mapsv) == 64);
|
|
|
|
v = sc_map_del_sv(&mapsv, keys[12]);
|
|
assert(sc_map_found(&mapsv));
|
|
assert(v == (void *) 12);
|
|
assert(sc_map_size_sv(&mapsv) == 63);
|
|
sc_map_clear_sv(&mapsv);
|
|
sc_map_term_sv(&mapsv);
|
|
|
|
uint64_t val;
|
|
struct sc_map_s64 maps64;
|
|
|
|
assert(sc_map_init_s64(&maps64, 0, 26));
|
|
for (int i = 0; i < 64; i++) {
|
|
sc_map_put_s64(&maps64, keys[i], i);
|
|
}
|
|
|
|
val = sc_map_get_s64(&maps64, keys[0]);
|
|
assert(sc_map_found(&maps64));
|
|
assert(val == 0);
|
|
assert(sc_map_size_s64(&maps64) == 64);
|
|
|
|
val = sc_map_del_s64(&maps64, keys[12]);
|
|
assert(sc_map_found(&maps64));
|
|
assert(val == 12);
|
|
assert(sc_map_size_s64(&maps64) == 63);
|
|
sc_map_clear_s64(&maps64);
|
|
sc_map_term_s64(&maps64);
|
|
|
|
for (int i = 0; i < 128; i++) {
|
|
free(keys[i]);
|
|
free(values[i]);
|
|
}
|
|
}
|
|
|
|
static void test5()
|
|
{
|
|
int t = 0;
|
|
uint64_t key, value;
|
|
struct sc_map_64 map;
|
|
|
|
sc_map_init_64(&map, 0, 0);
|
|
sc_map_put_64(&map, 0, 111);
|
|
|
|
t = 0;
|
|
sc_map_foreach (&map, key, value) {
|
|
assert(key == 0);
|
|
assert(value == 111);
|
|
|
|
t++;
|
|
}
|
|
assert(t == 1);
|
|
|
|
t = 0;
|
|
sc_map_foreach_key (&map, key) {
|
|
assert(key == 0);
|
|
t++;
|
|
}
|
|
assert(t == 1);
|
|
|
|
t = 0;
|
|
sc_map_foreach_value (&map, value) {
|
|
assert(value == 111);
|
|
t++;
|
|
}
|
|
assert(t == 1);
|
|
|
|
sc_map_term_64(&map);
|
|
}
|
|
|
|
static void test6()
|
|
{
|
|
const int count = 120000;
|
|
uint32_t val;
|
|
struct sc_map_32 map;
|
|
|
|
srand(time(NULL));
|
|
|
|
uint32_t *keys = malloc(sizeof(uint32_t) * count);
|
|
uint32_t *values = malloc(sizeof(uint32_t) * count);
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
keys[i] = i;
|
|
values[i] = (i * 33);
|
|
}
|
|
|
|
sc_map_init_32(&map, 0, 0);
|
|
for (int i = 0; i < count; i++) {
|
|
sc_map_put_32(&map, keys[i], values[i]);
|
|
|
|
if (i % 7 == 0 || i % 17 == 0 || i % 79 == 0) {
|
|
val = sc_map_del_32(&map, keys[i]);
|
|
assert(sc_map_found(&map));
|
|
assert(val == values[i]);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
if (i % 7 == 0 || i % 17 == 0 || i % 79 == 0) {
|
|
continue;
|
|
}
|
|
|
|
val = sc_map_get_32(&map, keys[i]);
|
|
assert(sc_map_found(&map));
|
|
assert(val == values[i]);
|
|
}
|
|
|
|
sc_map_term_32(&map);
|
|
|
|
free(keys);
|
|
free(values);
|
|
}
|
|
|
|
#ifdef SC_HAVE_WRAP
|
|
|
|
bool fail_calloc = false;
|
|
void *__real_calloc(size_t n, size_t size);
|
|
void *__wrap_calloc(size_t n, size_t size)
|
|
{
|
|
if (fail_calloc) {
|
|
return NULL;
|
|
}
|
|
|
|
return __real_calloc(n, size);
|
|
}
|
|
|
|
void fail_test_32()
|
|
{
|
|
struct sc_map_32 map;
|
|
|
|
fail_calloc = true;
|
|
assert(!sc_map_init_32(&map, 10, 0));
|
|
fail_calloc = false;
|
|
assert(sc_map_init_32(&map, 10, 0));
|
|
|
|
fail_calloc = true;
|
|
|
|
for (int i = 0; i < 20; i++) {
|
|
sc_map_put_32(&map, i, i);
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
sc_map_put_32(&map, 44444, 44444);
|
|
|
|
for (size_t i = 0; i < SC_MAP_MAX; i++) {
|
|
sc_map_put_32(&map, i, i);
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
|
|
sc_map_term_32(&map);
|
|
}
|
|
|
|
void fail_test_64()
|
|
{
|
|
struct sc_map_64 map;
|
|
|
|
fail_calloc = true;
|
|
assert(!sc_map_init_64(&map, 10, 0));
|
|
fail_calloc = false;
|
|
assert(sc_map_init_64(&map, 10, 0));
|
|
|
|
fail_calloc = true;
|
|
|
|
for (int i = 0; i < 20; i++) {
|
|
sc_map_put_64(&map, i, i);
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
sc_map_put_64(&map, 44444, 44444);
|
|
|
|
for (size_t i = 0; i < SC_MAP_MAX; i++) {
|
|
sc_map_put_64(&map, i, i);
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
|
|
sc_map_term_64(&map);
|
|
}
|
|
|
|
void fail_test_64v()
|
|
{
|
|
struct sc_map_64v map;
|
|
|
|
fail_calloc = true;
|
|
assert(!sc_map_init_64v(&map, 10, 0));
|
|
fail_calloc = false;
|
|
assert(sc_map_init_64v(&map, 10, 0));
|
|
|
|
fail_calloc = true;
|
|
|
|
for (int i = 0; i < 20; i++) {
|
|
sc_map_put_64v(&map, i, NULL);
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
sc_map_put_64v(&map, 44444, NULL);
|
|
|
|
for (size_t i = 0; i < SC_MAP_MAX; i++) {
|
|
sc_map_put_64v(&map, i, NULL);
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
|
|
sc_map_term_64v(&map);
|
|
}
|
|
|
|
void fail_test_64s()
|
|
{
|
|
struct sc_map_64s map;
|
|
|
|
fail_calloc = true;
|
|
assert(!sc_map_init_64s(&map, 10, 0));
|
|
fail_calloc = false;
|
|
assert(sc_map_init_64s(&map, 10, 0));
|
|
|
|
fail_calloc = true;
|
|
|
|
for (int i = 0; i < 20; i++) {
|
|
sc_map_put_64s(&map, i, NULL);
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
sc_map_put_64s(&map, 44444, NULL);
|
|
|
|
for (size_t i = 0; i < SC_MAP_MAX; i++) {
|
|
sc_map_put_64s(&map, i, NULL);
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
|
|
sc_map_term_64s(&map);
|
|
}
|
|
|
|
void fail_test_str()
|
|
{
|
|
struct sc_map_str map;
|
|
const char *v;
|
|
const char *s = "abcdefghijklmnoprstuvyz10111213141516";
|
|
|
|
fail_calloc = true;
|
|
assert(!sc_map_init_str(&map, 10, 0));
|
|
fail_calloc = false;
|
|
assert(sc_map_init_str(&map, 10, 0));
|
|
|
|
fail_calloc = true;
|
|
|
|
for (int i = 0; i < 20; i++) {
|
|
sc_map_put_str(&map, &s[i], NULL);
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
sc_map_put_str(&map, &s[21], NULL);
|
|
sc_map_clear_str(&map);
|
|
|
|
for (size_t i = 0; i < SC_MAP_MAX; i++) {
|
|
char *c = str_random(32);
|
|
|
|
sc_map_put_str(&map, c, NULL);
|
|
if (sc_map_oom(&map)) {
|
|
free(c);
|
|
break;
|
|
}
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
|
|
sc_map_foreach_key (&map, v) {
|
|
free((void *) v);
|
|
}
|
|
|
|
sc_map_term_str(&map);
|
|
}
|
|
|
|
void fail_test_sv()
|
|
{
|
|
struct sc_map_sv map;
|
|
const char *v;
|
|
const char *s = "abcdefghijklmnoprstuvyz10111213141516";
|
|
|
|
fail_calloc = true;
|
|
assert(!sc_map_init_sv(&map, 10, 0));
|
|
fail_calloc = false;
|
|
assert(sc_map_init_sv(&map, 10, 0));
|
|
|
|
fail_calloc = true;
|
|
|
|
for (int i = 0; i < 20; i++) {
|
|
sc_map_put_sv(&map, &s[i], NULL);
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
sc_map_put_sv(&map, &s[21], NULL);
|
|
sc_map_clear_sv(&map);
|
|
|
|
for (size_t i = 0; i < SC_MAP_MAX; i++) {
|
|
char *c = str_random(32);
|
|
sc_map_put_sv(&map, c, NULL);
|
|
if (sc_map_oom(&map)) {
|
|
free(c);
|
|
break;
|
|
}
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
|
|
sc_map_foreach_key (&map, v) {
|
|
free((void *) v);
|
|
}
|
|
|
|
sc_map_term_sv(&map);
|
|
}
|
|
|
|
void fail_test_s64()
|
|
{
|
|
struct sc_map_s64 map;
|
|
const char *v;
|
|
const char *s = "abcdefghijklmnoprstuvyz10111213141516";
|
|
|
|
fail_calloc = true;
|
|
assert(!sc_map_init_s64(&map, 10, 0));
|
|
fail_calloc = false;
|
|
assert(sc_map_init_s64(&map, 10, 0));
|
|
|
|
fail_calloc = true;
|
|
|
|
for (int i = 0; i < 20; i++) {
|
|
sc_map_put_s64(&map, &s[i], 0);
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
sc_map_put_s64(&map, &s[21], 0);
|
|
sc_map_clear_s64(&map);
|
|
|
|
for (size_t i = 0; i < SC_MAP_MAX; i++) {
|
|
char *c = str_random(32);
|
|
sc_map_put_s64(&map, c, 0);
|
|
if (sc_map_oom(&map)) {
|
|
free(c);
|
|
break;
|
|
}
|
|
}
|
|
assert(sc_map_oom(&map));
|
|
fail_calloc = false;
|
|
|
|
sc_map_foreach_key (&map, v) {
|
|
free((void *) v);
|
|
}
|
|
|
|
sc_map_term_s64(&map);
|
|
}
|
|
|
|
#else
|
|
void fail_test_32(void)
|
|
{
|
|
}
|
|
void fail_test_64(void)
|
|
{
|
|
}
|
|
void fail_test_64v(void)
|
|
{
|
|
}
|
|
void fail_test_64s(void)
|
|
{
|
|
}
|
|
void fail_test_str(void)
|
|
{
|
|
}
|
|
void fail_test_sv(void)
|
|
{
|
|
}
|
|
void fail_test_s64(void)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
int main()
|
|
{
|
|
example();
|
|
example_int_to_str();
|
|
fail_test_32();
|
|
fail_test_64();
|
|
fail_test_64v();
|
|
fail_test_64s();
|
|
fail_test_str();
|
|
fail_test_sv();
|
|
fail_test_s64();
|
|
test0();
|
|
test1();
|
|
test2();
|
|
test3();
|
|
test4();
|
|
test5();
|
|
test6();
|
|
test_32();
|
|
test_64();
|
|
test_64s();
|
|
test_64v();
|
|
test_str();
|
|
test_sv();
|
|
test_s64();
|
|
|
|
return 0;
|
|
}
|