prometheus-client-mmap 0.20.3-x86_64-linux-musl

data/vendor/c/hashmap/test/hashmap_test.c

@@ -0,0 +1,608 @@
+/*
+ * Copyright (c) 2016-2017 David Leeds <davidesleeds@gmail.com>
+ *
+ * Hashmap is free software; you can redistribute it and/or modify
+ * it under the terms of the MIT license. See LICENSE for details.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <time.h>
+#include <assert.h>
+
+#include <hashmap.h>
+
+#define ARRAY_LEN(array)	(sizeof(array) / sizeof(array[0]))
+
+#define TEST_NUM_KEYS		196607	/* Results in max load factor */
+#define TEST_KEY_STR_LEN	32
+
+void **keys_str_random;
+void **keys_str_sequential;
+void **keys_int_random;
+void **keys_int_sequential;
+
+struct hashmap str_map;
+struct hashmap int_map;
+
+struct test {
+	const char *name;
+	const char *description;
+	bool (*run)(struct hashmap *map, void **keys);
+	bool pre_load;
+};
+
+/*
+ * Test type-specific generation macros
+ */
+HASHMAP_FUNCS_DECLARE(test, const void, void)
+HASHMAP_FUNCS_CREATE(test, const void, void)
+
+
+uint64_t test_time_us(void)
+{
+	struct timespec now;
+
+	if (clock_gettime(CLOCK_MONOTONIC, &now)) {
+		assert(0);
+	}
+	return ((uint64_t)now.tv_sec) * 1000000 + (uint64_t)(now.tv_nsec / 1000);
+}
+
+void **test_keys_alloc(size_t num)
+{
+	void **keys;
+
+	keys = (void **)calloc(num, sizeof(void *));
+	if (!keys) {
+		printf("malloc failed\n");
+		exit(1);
+	}
+	return keys;
+}
+
+void *test_key_alloc_random_str(void)
+{
+	size_t i;
+	unsigned num;
+	char *key;
+
+	key = (char *)malloc(TEST_KEY_STR_LEN + 1);
+	if (!key) {
+		printf("malloc failed\n");
+		exit(1);
+	}
+	for (i = 0; i < TEST_KEY_STR_LEN; ++i) {
+		num = random();
+		num = (num % 96) + 32;	/* ASCII printable only */
+		key[i] = (char)num;
+	}
+	key[TEST_KEY_STR_LEN] = '\0';
+	return key;
+}
+void *test_key_alloc_random_int(void)
+{
+	uint64_t *key;
+
+	key = (uint64_t *)malloc(sizeof(*key));
+	if (!key) {
+		printf("malloc failed\n");
+		exit(1);
+	}
+	/* RAND_MAX is not guaranteed to be more than 32K */
+	*key = (uint64_t)(random() & 0xffff) << 48 |
+	    (uint64_t)(random() & 0xffff) << 32 |
+	    (uint64_t)(random() & 0xffff) << 16 |
+	    (uint64_t)(random() & 0xffff);
+	return key;
+}
+
+void *test_key_alloc_sequential_str(size_t index)
+{
+	char *key;
+
+	key = (char *)malloc(TEST_KEY_STR_LEN + 1);
+	if (!key) {
+		printf("malloc failed\n");
+		exit(1);
+	}
+	snprintf(key, TEST_KEY_STR_LEN + 1, "sequential key! %010zu", index);
+	return key;
+}
+
+void *test_key_alloc_sequential_int(size_t index)
+{
+	uint64_t *key;
+
+	key = (uint64_t *)malloc(sizeof(*key));
+	if (!key) {
+		printf("malloc failed\n");
+		exit(1);
+	}
+	*key = index;
+	return key;
+}
+
+void test_keys_generate(void)
+{
+	size_t i;
+
+	srandom(99);	/* Use reproducible random sequences */
+
+	keys_str_random =  test_keys_alloc(TEST_NUM_KEYS + 1);
+	keys_str_sequential =  test_keys_alloc(TEST_NUM_KEYS + 1);
+	keys_int_random =  test_keys_alloc(TEST_NUM_KEYS + 1);
+	keys_int_sequential =  test_keys_alloc(TEST_NUM_KEYS + 1);
+	for (i = 0; i < TEST_NUM_KEYS; ++i) {
+		keys_str_random[i] = test_key_alloc_random_str();
+		keys_str_sequential[i] = test_key_alloc_sequential_str(i);
+		keys_int_random[i] = test_key_alloc_random_int();
+		keys_int_sequential[i] = test_key_alloc_sequential_int(i);
+	}
+	keys_str_random[i] = NULL;
+	keys_str_sequential[i] = NULL;
+	keys_int_random[i] = NULL;
+	keys_int_sequential[i] = NULL;
+}
+
+void test_load_keys(struct hashmap *map, void **keys)
+{
+	void **key;
+
+	for (key = keys; *key; ++key) {
+		if (!test_hashmap_put(map, *key, *key)) {
+			printf("hashmap_put() failed");
+			exit(1);
+		}
+	}
+}
+
+void test_reset_map(struct hashmap *map)
+{
+	hashmap_reset(map);
+}
+
+void test_print_stats(struct hashmap *map, const char *label)
+{
+	printf("Hashmap stats: %s\n", label);
+	printf("    # entries:           %zu\n", hashmap_size(map));
+	printf("    Table size:          %zu\n", map->table_size);
+	printf("    Load factor:         %.4f\n", hashmap_load_factor(map));
+	printf("    Collisions mean:     %.4f\n", hashmap_collisions_mean(map));
+	printf("    Collisions variance: %.4f\n",
+	    hashmap_collisions_variance(map));
+
+}
+
+bool test_run(struct hashmap *map, void **keys, const struct test *t)
+{
+	bool success;
+	uint64_t time_us;
+
+	assert(t != NULL);
+	assert(t->name != NULL);
+	assert(t->run != NULL);
+
+	if (t->pre_load) {
+		printf("Pre-loading keys...");
+		test_load_keys(map, keys);
+		printf("done\n");
+	}
+	printf("Running...\n");
+	time_us = test_time_us();
+	success = t->run(map, keys);
+	time_us = test_time_us() - time_us;
+	if (success) {
+		printf("Completed successfully\n");
+	} else {
+		printf("Failed\n");
+	}
+	printf("Run time: %llu microseconds\n", (long long unsigned)time_us);
+	test_print_stats(map, t->name);
+	test_reset_map(map);
+	return success;
+}
+
+bool test_run_all(struct hashmap *map, void **keys,
+	const struct test *tests, size_t num_tests, const char *env)
+{
+	const struct test *t;
+	size_t num_failed = 0;
+
+	printf("\n**************************************************\n");
+	printf("Starting test series:\n");
+	printf("    %s\n", env);
+	printf("**************************************************\n\n");
+	for (t = tests; t < &tests[num_tests]; ++t) {
+		printf("\n**************************************************"
+		    "\n");
+		printf("Test %02u: %s\n", (unsigned)(t - tests) + 1, t->name);
+		if (t->description) {
+			printf("    Description: %s\n", t->description);
+		}
+		printf("\n");
+		if (!test_run(map, keys, t)) {
+			++num_failed;
+		}
+	}
+	printf("\n**************************************************\n");
+	printf("Test results:\n");
+	printf("    Passed: %zu\n", num_tests - num_failed);
+	printf("    Failed: %zu\n", num_failed);
+	printf("**************************************************\n");
+	return (num_failed == 0);
+}
+
+size_t test_hash_uint64(const void *key)
+{
+	const uint8_t *byte = (const uint8_t *)key;
+	uint8_t i;
+	size_t hash = 0;
+
+	for (i = 0; i < sizeof(uint64_t); ++i, ++byte) {
+		hash += *byte;
+		hash += (hash << 10);
+		hash ^= (hash >> 6);
+	}
+	hash += (hash << 3);
+	hash ^= (hash >> 11);
+	hash += (hash << 15);
+	return hash;
+}
+
+int test_compare_uint64(const void *a, const void *b)
+{
+	return *(int64_t *)a - *(int64_t *)b;
+}
+
+bool test_put(struct hashmap *map, void **keys)
+{
+	void **key;
+	void *data;
+
+	for (key = keys; *key; ++key) {
+		data = test_hashmap_put(map, *key, *key);
+		if (!data) {
+			printf("malloc failed\n");
+			exit(1);
+		}
+		if (data != *key) {
+			printf("duplicate key found\n");
+			return false;
+		}
+	}
+	return true;
+}
+
+bool test_put_existing(struct hashmap *map, void **keys)
+{
+	void **key;
+	void *data;
+	int temp_data = 99;
+
+	for (key = keys; *key; ++key) {
+		data = hashmap_put(map, *key, &temp_data);
+		if (!data) {
+			printf("malloc failed\n");
+			exit(1);
+		}
+		if (data != *key) {
+			printf("did not return existing data\n");
+			return false;
+		}
+	}
+	return true;
+}
+
+bool test_get(struct hashmap *map, void **keys)
+{
+	void **key;
+	void *data;
+
+	for (key = keys; *key; ++key) {
+		data = test_hashmap_get(map, *key);
+		if (!data) {
+			printf("entry not found\n");
+			return false;
+		}
+		if (data != *key) {
+			printf("got wrong entry\n");
+			return false;
+		}
+	}
+	return true;
+}
+
+bool test_get_nonexisting(struct hashmap *map, void **keys)
+{
+	void **key;
+	void *data;
+	const char *fake_key = "test_get_nonexisting fake key!";
+
+	for (key = keys; *key; ++key) {
+		data = hashmap_get(map, fake_key);
+		if (data) {
+			printf("unexpected entry found\n");
+			return false;
+		}
+	}
+	return true;
+}
+
+bool test_remove(struct hashmap *map, void **keys)
+{
+	void **key;
+	void *data;
+
+	for (key = keys; *key; ++key) {
+		data = test_hashmap_remove(map, *key);
+		if (!data) {
+			printf("entry not found\n");
+			return false;
+		}
+		if (data != *key) {
+			printf("removed wrong entry\n");
+			return false;
+		}
+	}
+	return true;
+}
+
+bool test_put_remove(struct hashmap *map, void **keys)
+{
+	size_t i = 0;
+	void **key;
+	void *data;
+
+	if (!test_put(map, keys)) {
+		return false;
+	}
+	for (key = keys; *key; ++key) {
+		if (i++ >= TEST_NUM_KEYS / 2) {
+			break;
+		}
+		data = test_hashmap_remove(map, *key);
+		if (!data) {
+			printf("key not found\n");
+			return false;
+		}
+		if (data != *key) {
+			printf("removed wrong entry\n");
+			return false;
+		}
+	}
+	test_print_stats(map, "test_put_remove done");
+	i = 0;
+	for (key = keys; *key; ++key) {
+		if (i++ >= TEST_NUM_KEYS / 2) {
+			break;
+		}
+		data = test_hashmap_put(map, *key, *key);
+		if (!data) {
+			printf("malloc failed\n");
+			exit(1);
+		}
+		if (data != *key) {
+			printf("duplicate key found\n");
+			return false;
+		}
+	}
+	return true;
+}
+
+bool test_iterate(struct hashmap *map, void **keys)
+{
+	size_t i = 0;
+	struct hashmap_iter *iter = hashmap_iter(map);
+
+	for (; iter; iter = hashmap_iter_next(map, iter)) {
+		++i;
+	}
+	if (i != TEST_NUM_KEYS) {
+		printf("did not iterate through all entries: "
+		    "observed %zu, expected %u\n", i, TEST_NUM_KEYS);
+		return false;
+	}
+	return true;
+}
+
+bool test_iterate_remove(struct hashmap *map, void **keys)
+{
+	size_t i = 0;
+	struct hashmap_iter *iter = hashmap_iter(map);
+	const void *key;
+
+	while (iter) {
+		++i;
+		key = test_hashmap_iter_get_key(iter);
+		if (test_hashmap_get(map, key) != key) {
+			printf("invalid iterator on entry #%zu\n", i);
+			return false;
+		}
+		iter = hashmap_iter_remove(map, iter);
+		if (test_hashmap_get(map, key) != NULL) {
+			printf("iter_remove failed on entry #%zu\n", i);
+			return false;
+		}
+	}
+	if (i != TEST_NUM_KEYS) {
+		printf("did not iterate through all entries: "
+		    "observed %zu, expected %u\n", i, TEST_NUM_KEYS);
+		return false;
+	}
+	return true;
+}
+
+struct test_foreach_arg {
+	struct hashmap *map;
+	size_t i;
+};
+
+int test_foreach_callback(const void *key, void *data, void *arg)
+{
+	struct test_foreach_arg *state = (struct test_foreach_arg *)arg;
+
+	if (state->i & 1) {
+		/* Remove every other key */
+		if (!test_hashmap_remove(state->map, key)) {
+			printf("could not remove expected key\n");
+			return -1;
+		}
+	}
+	++state->i;
+	return 0;
+}
+
+bool test_foreach(struct hashmap *map, void **keys)
+{
+	struct test_foreach_arg arg = { map, 1 };
+	size_t size = hashmap_size(map);
+
+	if (test_hashmap_foreach(map, test_foreach_callback, &arg) < 0) {
+		return false;
+	}
+	if (hashmap_size(map) != size / 2) {
+		printf("foreach delete did not remove expected # of entries: "
+		    "contains %zu vs. expected %zu\n", hashmap_size(map),
+		    size / 2);
+		return false;
+	}
+	return true;
+}
+
+bool test_clear(struct hashmap *map, void **keys)
+{
+	hashmap_clear(map);
+	return true;
+}
+
+bool test_reset(struct hashmap *map, void **keys)
+{
+	hashmap_reset(map);
+	return true;
+}
+
+const struct test const tests[] = {
+	{
+		.name = "put performance",
+		.description = "put new hash keys",
+		.run = test_put
+	},
+	{
+		.name = "put existing performance",
+		.description = "attempt to put existing hash keys",
+		.run = test_put_existing,
+		.pre_load = true
+	},
+	{
+		.name = "get existing performance",
+		.description = "get existing hash keys",
+		.run = test_get,
+		.pre_load = true
+	},
+	{
+		.name = "get non-existing performance",
+		.description = "get nonexistent hash keys",
+		.run = test_get_nonexisting,
+		.pre_load = true
+	},
+	{
+		.name = "remove performance",
+		.description = "remove hash keys",
+		.run = test_remove,
+		.pre_load = true
+	},
+	{
+		.name = "mixed put/remove performance",
+		.description = "put, remove 1/2, then put them back",
+		.run = test_put_remove
+	},
+	{
+		.name = "iterate performance",
+		.description = "iterate through entries",
+		.run = test_iterate,
+		.pre_load = true
+	},
+	{
+		.name = "iterate remove all",
+		.description = "iterate and remove all entries",
+		.run = test_iterate_remove,
+		.pre_load = true
+	},
+	{
+		.name = "removal in foreach",
+		.description = "iterate and delete 1/2 using hashmap_foreach",
+		.run = test_foreach,
+		.pre_load = true
+	},
+	{
+		.name = "clear performance",
+		.description = "clear entries",
+		.run = test_clear,
+		.pre_load = true
+	},
+	{
+		.name = "reset performance",
+		.description = "reset entries",
+		.run = test_reset,
+		.pre_load = true
+	}
+};
+
+/*
+ * Main function
+ */
+int main(int argc, char **argv)
+{
+	bool success = true;
+
+	/* Initialize */
+	printf("Initializing hash maps...");
+	if (hashmap_init(&str_map, hashmap_hash_string, hashmap_compare_string,
+	    0) < 0) {
+		success = false;
+	}
+	/*
+	hashmap_set_key_alloc_funcs(&str_map, hashmap_alloc_key_string, free);
+	*/
+	if (hashmap_init(&int_map, test_hash_uint64, test_compare_uint64,
+	    0) < 0) {
+		success = false;
+	}
+	printf("done\n");
+
+	if (!success) {
+		printf("Hashmap init failed");
+		return 1;
+	}
+
+	printf("Generating test %u test keys...", TEST_NUM_KEYS);
+	test_keys_generate();
+	printf("done\n");
+
+	printf("Running tests\n\n");
+	success &= test_run_all(&str_map, keys_str_random, tests,
+	    ARRAY_LEN(tests), "Hashmap w/randomized string keys");
+	success &= test_run_all(&str_map, keys_str_sequential, tests,
+	    ARRAY_LEN(tests), "Hashmap w/sequential string keys");
+
+	success &= test_run_all(&int_map, keys_int_random, tests,
+	    ARRAY_LEN(tests), "Hashmap w/randomized integer keys");
+
+	success &= test_run_all(&int_map, keys_int_sequential, tests,
+	    ARRAY_LEN(tests), "Hashmap w/sequential integer keys");
+
+	printf("\nTests finished\n");
+
+	hashmap_destroy(&str_map);
+	hashmap_destroy(&int_map);
+
+	if (!success) {
+		printf("Tests FAILED\n");
+		exit(1);
+	}
+	return 0;
+}

data/vendor/c/jsmn/.travis.yml

@@ -0,0 +1,4 @@
+language: c
+sudo: false
+script:
+  - make test

data/vendor/c/jsmn/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Serge A. Zaitsev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/vendor/c/jsmn/Makefile

@@ -0,0 +1,41 @@
+# You can put your build options here
+-include config.mk
+
+all: libjsmn.a 
+
+libjsmn.a: jsmn.o
+	$(AR) rc $@ $^
+
+%.o: %.c jsmn.h
+	$(CC) -c $(CFLAGS) $< -o $@
+
+test: test_default test_strict test_links test_strict_links
+test_default: test/tests.c
+	$(CC) $(CFLAGS) $(LDFLAGS) $< -o test/$@
+	./test/$@
+test_strict: test/tests.c
+	$(CC) -DJSMN_STRICT=1 $(CFLAGS) $(LDFLAGS) $< -o test/$@
+	./test/$@
+test_links: test/tests.c
+	$(CC) -DJSMN_PARENT_LINKS=1 $(CFLAGS) $(LDFLAGS) $< -o test/$@
+	./test/$@
+test_strict_links: test/tests.c
+	$(CC) -DJSMN_STRICT=1 -DJSMN_PARENT_LINKS=1 $(CFLAGS) $(LDFLAGS) $< -o test/$@
+	./test/$@
+
+jsmn_test.o: jsmn_test.c libjsmn.a
+
+simple_example: example/simple.o libjsmn.a
+	$(CC) $(LDFLAGS) $^ -o $@
+
+jsondump: example/jsondump.o libjsmn.a
+	$(CC) $(LDFLAGS) $^ -o $@
+
+clean:
+	rm -f *.o example/*.o
+	rm -f *.a *.so
+	rm -f simple_example
+	rm -f jsondump
+
+.PHONY: all clean test
+