Rename non-static functions to have a _p11_xxx prefix.

 * Work around issues with brain-dead linkers not respecting
   the libtool -export-symbol-regex argument

https://bugs.freedesktop.org/show_bug.cgi?id=42020

6 files changed, 232 insertions, 229 deletions

diff --git a/tests/conf-test.c b/tests/conf-test.c
index 58cb2f4..b86ffa7 100644
--- a/tests/conf-test.c
+++ b/tests/conf-test.c
@@ -53,19 +53,19 @@ test_parse_conf_1 (CuTest *tc)
 	map = _p11_conf_parse_file (SRCDIR "/files/test-1.conf", 0);
 	CuAssertPtrNotNull (tc, map);
 
-	value = hash_get (map, "key1");
+	value = _p11_hash_get (map, "key1");
 	CuAssertStrEquals (tc, "value1", value);
 
-	value = hash_get (map, "with-colon");
+	value = _p11_hash_get (map, "with-colon");
 	CuAssertStrEquals (tc, "value-of-colon", value);
 
-	value = hash_get (map, "with-whitespace");
+	value = _p11_hash_get (map, "with-whitespace");
 	CuAssertStrEquals (tc, "value-with-whitespace", value);
 
-	value = hash_get (map, "embedded-comment");
+	value = _p11_hash_get (map, "embedded-comment");
 	CuAssertStrEquals (tc, "this is # not a comment", value);
 
-	hash_free (map);
+	_p11_hash_free (map);
 }
 
 static void
@@ -76,9 +76,9 @@ test_parse_ignore_missing (CuTest *tc)
 	map = _p11_conf_parse_file (SRCDIR "/files/non-existant.conf", CONF_IGNORE_MISSING);
 	CuAssertPtrNotNull (tc, map);
 
-	CuAssertIntEquals (tc, 0, hash_size (map));
+	CuAssertIntEquals (tc, 0, _p11_hash_size (map));
 	CuAssertPtrEquals (tc, NULL, (void*)p11_kit_message ());
-	hash_free (map);
+	_p11_hash_free (map);
 }
 
 static void
@@ -97,25 +97,25 @@ test_merge_defaults (CuTest *tc)
 	hashmap *values;
 	hashmap *defaults;
 
-	values = hash_create (hash_string_hash, hash_string_equal, free, free);
-	defaults = hash_create (hash_string_hash, hash_string_equal, free, free);
+	values = _p11_hash_create (_p11_hash_string_hash, _p11_hash_string_equal, free, free);
+	defaults = _p11_hash_create (_p11_hash_string_hash, _p11_hash_string_equal, free, free);
 
-	hash_set (values, strdup ("one"), strdup ("real1"));
-	hash_set (values, strdup ("two"), strdup ("real2"));
+	_p11_hash_set (values, strdup ("one"), strdup ("real1"));
+	_p11_hash_set (values, strdup ("two"), strdup ("real2"));
 
-	hash_set (defaults, strdup ("two"), strdup ("default2"));
-	hash_set (defaults, strdup ("three"), strdup ("default3"));
+	_p11_hash_set (defaults, strdup ("two"), strdup ("default2"));
+	_p11_hash_set (defaults, strdup ("three"), strdup ("default3"));
 
 	if (_p11_conf_merge_defaults (values, defaults) < 0)
 		CuFail (tc, "should not be reached");
 
-	hash_free (defaults);
+	_p11_hash_free (defaults);
 
-	CuAssertStrEquals (tc, hash_get (values, "one"), "real1");
-	CuAssertStrEquals (tc, hash_get (values, "two"), "real2");
-	CuAssertStrEquals (tc, hash_get (values, "three"), "default3");
+	CuAssertStrEquals (tc, _p11_hash_get (values, "one"), "real1");
+	CuAssertStrEquals (tc, _p11_hash_get (values, "two"), "real2");
+	CuAssertStrEquals (tc, _p11_hash_get (values, "three"), "default3");
 
-	hash_free (values);
+	_p11_hash_free (values);
 }
 
 static void
@@ -133,11 +133,11 @@ test_load_globals_merge (CuTest *tc)
 	CuAssertStrEquals (tc, NULL, p11_kit_message ());
 	CuAssertIntEquals (tc, CONF_USER_MERGE, user_mode);
 
-	CuAssertStrEquals (tc, hash_get (config, "key1"), "system1");
-	CuAssertStrEquals (tc, hash_get (config, "key2"), "user2");
-	CuAssertStrEquals (tc, hash_get (config, "key3"), "user3");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "key1"), "system1");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "key2"), "user2");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "key3"), "user3");
 
-	hash_free (config);
+	_p11_hash_free (config);
 }
 
 static void
@@ -155,11 +155,11 @@ test_load_globals_no_user (CuTest *tc)
 	CuAssertStrEquals (tc, NULL, p11_kit_message ());
 	CuAssertIntEquals (tc, CONF_USER_NONE, user_mode);
 
-	CuAssertStrEquals (tc, hash_get (config, "key1"), "system1");
-	CuAssertStrEquals (tc, hash_get (config, "key2"), "system2");
-	CuAssertStrEquals (tc, hash_get (config, "key3"), "system3");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "key1"), "system1");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "key2"), "system2");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "key3"), "system3");
 
-	hash_free (config);
+	_p11_hash_free (config);
 }
 
 static void
@@ -177,11 +177,11 @@ test_load_globals_user_sets_only (CuTest *tc)
 	CuAssertStrEquals (tc, NULL, p11_kit_message ());
 	CuAssertIntEquals (tc, CONF_USER_ONLY, user_mode);
 
-	CuAssertStrEquals (tc, hash_get (config, "key1"), NULL);
-	CuAssertStrEquals (tc, hash_get (config, "key2"), "user2");
-	CuAssertStrEquals (tc, hash_get (config, "key3"), "user3");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "key1"), NULL);
+	CuAssertStrEquals (tc, _p11_hash_get (config, "key2"), "user2");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "key3"), "user3");
 
-	hash_free (config);
+	_p11_hash_free (config);
 }
 
 static void
@@ -199,11 +199,11 @@ test_load_globals_system_sets_only (CuTest *tc)
 	CuAssertStrEquals (tc, NULL, p11_kit_message ());
 	CuAssertIntEquals (tc, CONF_USER_ONLY, user_mode);
 
-	CuAssertStrEquals (tc, hash_get (config, "key1"), NULL);
-	CuAssertStrEquals (tc, hash_get (config, "key2"), "user2");
-	CuAssertStrEquals (tc, hash_get (config, "key3"), "user3");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "key1"), NULL);
+	CuAssertStrEquals (tc, _p11_hash_get (config, "key2"), "user2");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "key3"), "user3");
 
-	hash_free (config);
+	_p11_hash_free (config);
 }
 
 static void
@@ -223,7 +223,7 @@ test_load_globals_system_sets_invalid (CuTest *tc)
 	CuAssertIntEquals (tc, EINVAL, error);
 	CuAssertPtrNotNull (tc, p11_kit_message ());
 
-	hash_free (config);
+	_p11_hash_free (config);
 }
 
 static void
@@ -243,7 +243,7 @@ test_load_globals_user_sets_invalid (CuTest *tc)
 	CuAssertIntEquals (tc, EINVAL, error);
 	CuAssertPtrNotNull (tc, p11_kit_message ());
 
-	hash_free (config);
+	_p11_hash_free (config);
 }
 
 static void
@@ -260,22 +260,22 @@ test_load_modules_merge (CuTest *tc)
 	CuAssertPtrNotNull (tc, configs);
 	CuAssertStrEquals (tc, NULL, p11_kit_message ());
 
-	config = hash_get (configs, "one");
+	config = _p11_hash_get (configs, "one");
 	CuAssertPtrNotNull (tc, config);
-	CuAssertStrEquals (tc, hash_get (config, "module"), "/path/to/module-one");
-	CuAssertStrEquals (tc, hash_get (config, "setting"), "user1");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "module"), "/path/to/module-one");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "setting"), "user1");
 
-	config = hash_get (configs, "two");
+	config = _p11_hash_get (configs, "two");
 	CuAssertPtrNotNull (tc, config);
-	CuAssertStrEquals (tc, hash_get (config, "module"), "/path/to/module-two");
-	CuAssertStrEquals (tc, hash_get (config, "setting"), "system2");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "module"), "/path/to/module-two");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "setting"), "system2");
 
-	config = hash_get (configs, "three");
+	config = _p11_hash_get (configs, "three");
 	CuAssertPtrNotNull (tc, config);
-	CuAssertStrEquals (tc, hash_get (config, "module"), "/path/to/module-three");
-	CuAssertStrEquals (tc, hash_get (config, "setting"), "user3");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "module"), "/path/to/module-three");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "setting"), "user3");
 
-	hash_free (configs);
+	_p11_hash_free (configs);
 }
 
 static void
@@ -292,20 +292,20 @@ test_load_modules_user_none (CuTest *tc)
 	CuAssertPtrNotNull (tc, configs);
 	CuAssertStrEquals (tc, NULL, p11_kit_message ());
 
-	config = hash_get (configs, "one");
+	config = _p11_hash_get (configs, "one");
 	CuAssertPtrNotNull (tc, config);
-	CuAssertStrEquals (tc, hash_get (config, "module"), "/path/to/module-one");
-	CuAssertStrEquals (tc, hash_get (config, "setting"), "system1");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "module"), "/path/to/module-one");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "setting"), "system1");
 
-	config = hash_get (configs, "two");
+	config = _p11_hash_get (configs, "two");
 	CuAssertPtrNotNull (tc, config);
-	CuAssertStrEquals (tc, hash_get (config, "module"), "/path/to/module-two");
-	CuAssertStrEquals (tc, hash_get (config, "setting"), "system2");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "module"), "/path/to/module-two");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "setting"), "system2");
 
-	config = hash_get (configs, "three");
+	config = _p11_hash_get (configs, "three");
 	CuAssertPtrEquals (tc, NULL, config);
 
-	hash_free (configs);
+	_p11_hash_free (configs);
 }
 
 static void
@@ -322,20 +322,20 @@ test_load_modules_user_only (CuTest *tc)
 	CuAssertPtrNotNull (tc, configs);
 	CuAssertStrEquals (tc, NULL, p11_kit_message ());
 
-	config = hash_get (configs, "one");
+	config = _p11_hash_get (configs, "one");
 	CuAssertPtrNotNull (tc, config);
-	CuAssertStrEquals (tc, hash_get (config, "module"), NULL);
-	CuAssertStrEquals (tc, hash_get (config, "setting"), "user1");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "module"), NULL);
+	CuAssertStrEquals (tc, _p11_hash_get (config, "setting"), "user1");
 
-	config = hash_get (configs, "two");
+	config = _p11_hash_get (configs, "two");
 	CuAssertPtrEquals (tc, NULL, config);
 
-	config = hash_get (configs, "three");
+	config = _p11_hash_get (configs, "three");
 	CuAssertPtrNotNull (tc, config);
-	CuAssertStrEquals (tc, hash_get (config, "module"), "/path/to/module-three");
-	CuAssertStrEquals (tc, hash_get (config, "setting"), "user3");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "module"), "/path/to/module-three");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "setting"), "user3");
 
-	hash_free (configs);
+	_p11_hash_free (configs);
 }
 
 static void
@@ -352,20 +352,20 @@ test_load_modules_no_user (CuTest *tc)
 	CuAssertPtrNotNull (tc, configs);
 	CuAssertStrEquals (tc, NULL, p11_kit_message ());
 
-	config = hash_get (configs, "one");
+	config = _p11_hash_get (configs, "one");
 	CuAssertPtrNotNull (tc, config);
-	CuAssertStrEquals (tc, hash_get (config, "module"), "/path/to/module-one");
-	CuAssertStrEquals (tc, hash_get (config, "setting"), "system1");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "module"), "/path/to/module-one");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "setting"), "system1");
 
-	config = hash_get (configs, "two");
+	config = _p11_hash_get (configs, "two");
 	CuAssertPtrNotNull (tc, config);
-	CuAssertStrEquals (tc, hash_get (config, "module"), "/path/to/module-two");
-	CuAssertStrEquals (tc, hash_get (config, "setting"), "system2");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "module"), "/path/to/module-two");
+	CuAssertStrEquals (tc, _p11_hash_get (config, "setting"), "system2");
 
-	config = hash_get (configs, "three");
+	config = _p11_hash_get (configs, "three");
 	CuAssertPtrEquals (tc, NULL, config);
 
-	hash_free (configs);
+	_p11_hash_free (configs);
 }
 
 int
diff --git a/tests/hash-test.c b/tests/hash-test.c
index 73edeab..b8fc69f 100644
--- a/tests/hash-test.c
+++ b/tests/hash-test.c
@@ -42,19 +42,19 @@
 #include "hashmap.h"
 
 static void
-test_hash_create (CuTest *tc)
+test__p11_hash_create (CuTest *tc)
 {
 	hashmap *map;
 
-	map = hash_create (hash_direct_hash, hash_direct_equal, NULL, NULL);
+	map = _p11_hash_create (_p11_hash_direct_hash, _p11_hash_direct_equal, NULL, NULL);
 	CuAssertPtrNotNull (tc, map);
-	hash_free (map);
+	_p11_hash_free (map);
 }
 
 static void
-test_hash_free_null (CuTest *tc)
+test__p11_hash_free_null (CuTest *tc)
 {
-	hash_free (NULL);
+	_p11_hash_free (NULL);
 }
 
 static void
@@ -72,24 +72,24 @@ destroy_value (void *data)
 }
 
 static void
-test_hash_free_destroys (CuTest *tc)
+test__p11_hash_free_destroys (CuTest *tc)
 {
 	hashmap *map;
 	int key = 0;
 	int value = 0;
 
-	map = hash_create (hash_direct_hash, hash_direct_equal, destroy_key, destroy_value);
+	map = _p11_hash_create (_p11_hash_direct_hash, _p11_hash_direct_equal, destroy_key, destroy_value);
 	CuAssertPtrNotNull (tc, map);
-	if (!hash_set (map, &key, &value))
+	if (!_p11_hash_set (map, &key, &value))
 		CuFail (tc, "should not be reached");
-	hash_free (map);
+	_p11_hash_free (map);
 
 	CuAssertIntEquals (tc, 1, key);
 	CuAssertIntEquals (tc, 2, value);
 }
 
 static void
-test_hash_iterate (CuTest *tc)
+test__p11_hash_iterate (CuTest *tc)
 {
 	hashmap *map;
 	hashiter iter;
@@ -99,42 +99,42 @@ test_hash_iterate (CuTest *tc)
 	void *pvalue;
 	int ret;
 
-	map = hash_create (hash_direct_hash, hash_direct_equal, NULL, NULL);
+	map = _p11_hash_create (_p11_hash_direct_hash, _p11_hash_direct_equal, NULL, NULL);
 	CuAssertPtrNotNull (tc, map);
-	if (!hash_set (map, &key, &value))
+	if (!_p11_hash_set (map, &key, &value))
 		CuFail (tc, "should not be reached");
 
-	hash_iterate (map, &iter);
+	_p11_hash_iterate (map, &iter);
 
-	ret = hash_next (&iter, &pkey, &pvalue);
+	ret = _p11_hash_next (&iter, &pkey, &pvalue);
 	CuAssertIntEquals (tc, 1, ret);
 	CuAssertPtrEquals (tc, pkey, &key);
 	CuAssertPtrEquals (tc, pvalue, &value);
 
-	ret = hash_next (&iter, &pkey, &pvalue);
+	ret = _p11_hash_next (&iter, &pkey, &pvalue);
 	CuAssertIntEquals (tc, 0, ret);
 
-	hash_free (map);
+	_p11_hash_free (map);
 }
 
 static void
-test_hash_set_get (CuTest *tc)
+test__p11_hash_set_get (CuTest *tc)
 {
 	char *key = "KEY";
 	char *value = "VALUE";
 	char *check;
 	hashmap *map;
 
-	map = hash_create (hash_string_hash, hash_string_equal, NULL, NULL);
-	hash_set (map, key, value);
-	check = hash_get (map, key);
+	map = _p11_hash_create (_p11_hash_string_hash, _p11_hash_string_equal, NULL, NULL);
+	_p11_hash_set (map, key, value);
+	check = _p11_hash_get (map, key);
 	CuAssertPtrEquals (tc, check, value);
 
-	hash_free (map);
+	_p11_hash_free (map);
 }
 
 static void
-test_hash_set_get_remove (CuTest *tc)
+test__p11_hash_set_get_remove (CuTest *tc)
 {
 	char *key = "KEY";
 	char *value = "VALUE";
@@ -142,63 +142,63 @@ test_hash_set_get_remove (CuTest *tc)
 	hashmap *map;
 	int ret;
 
-	map = hash_create (hash_string_hash, hash_string_equal, NULL, NULL);
+	map = _p11_hash_create (_p11_hash_string_hash, _p11_hash_string_equal, NULL, NULL);
 
-	if (!hash_set (map, key, value))
+	if (!_p11_hash_set (map, key, value))
 		CuFail (tc, "should not be reached");
 
-	check = hash_get (map, key);
+	check = _p11_hash_get (map, key);
 	CuAssertPtrEquals (tc, check, value);
 
-	ret = hash_remove (map, key);
+	ret = _p11_hash_remove (map, key);
 	CuAssertIntEquals (tc, ret, 1);
-	ret = hash_remove (map, key);
+	ret = _p11_hash_remove (map, key);
 	CuAssertIntEquals (tc, ret, 0);
 
-	check = hash_get (map, key);
+	check = _p11_hash_get (map, key);
 	CuAssert (tc, "should be null", check == NULL);
 
-	hash_free (map);
+	_p11_hash_free (map);
 }
 
 static void
-test_hash_set_get_clear (CuTest *tc)
+test__p11_hash_set_get_clear (CuTest *tc)
 {
 	char *key = "KEY";
 	char *value = "VALUE";
 	char *check;
 	hashmap *map;
 
-	map = hash_create (hash_direct_hash, hash_direct_equal, NULL, NULL);
+	map = _p11_hash_create (_p11_hash_direct_hash, _p11_hash_direct_equal, NULL, NULL);
 
-	if (!hash_set (map, key, value))
+	if (!_p11_hash_set (map, key, value))
 		CuFail (tc, "should not be reached");
 
-	check = hash_get (map, key);
+	check = _p11_hash_get (map, key);
 	CuAssertPtrEquals (tc, check, value);
 
-	hash_clear (map);
+	_p11_hash_clear (map);
 
-	check = hash_get (map, key);
+	check = _p11_hash_get (map, key);
 	CuAssert (tc, "should be null", check == NULL);
 
-	hash_free (map);
+	_p11_hash_free (map);
 }
 
 static void
-test_hash_remove_destroys (CuTest *tc)
+test__p11_hash_remove_destroys (CuTest *tc)
 {
 	hashmap *map;
 	int key = 0;
 	int value = 0;
 	int ret;
 
-	map = hash_create (hash_direct_hash, hash_direct_equal, destroy_key, destroy_value);
+	map = _p11_hash_create (_p11_hash_direct_hash, _p11_hash_direct_equal, destroy_key, destroy_value);
 	CuAssertPtrNotNull (tc, map);
-	if (!hash_set (map, &key, &value))
+	if (!_p11_hash_set (map, &key, &value))
 		CuFail (tc, "should not be reached");
 
-	ret = hash_remove (map, &key);
+	ret = _p11_hash_remove (map, &key);
 	CuAssertIntEquals (tc, ret, 1);
 	CuAssertIntEquals (tc, 1, key);
 	CuAssertIntEquals (tc, 2, value);
@@ -207,7 +207,7 @@ test_hash_remove_destroys (CuTest *tc)
 	key = 0;
 	value = 0;
 
-	ret = hash_remove (map, &key);
+	ret = _p11_hash_remove (map, &key);
 	CuAssertIntEquals (tc, ret, 0);
 	CuAssertIntEquals (tc, 0, key);
 	CuAssertIntEquals (tc, 0, value);
@@ -216,14 +216,14 @@ test_hash_remove_destroys (CuTest *tc)
 	key = 0;
 	value = 0;
 
-	hash_free (map);
+	_p11_hash_free (map);
 
 	CuAssertIntEquals (tc, 0, key);
 	CuAssertIntEquals (tc, 0, value);
 }
 
 static void
-test_hash_set_destroys (CuTest *tc)
+test__p11_hash_set_destroys (CuTest *tc)
 {
 	hashmap *map;
 	int key = 0;
@@ -231,12 +231,12 @@ test_hash_set_destroys (CuTest *tc)
 	int value2 = 0;
 	int ret;
 
-	map = hash_create (hash_direct_hash, hash_direct_equal, destroy_key, destroy_value);
+	map = _p11_hash_create (_p11_hash_direct_hash, _p11_hash_direct_equal, destroy_key, destroy_value);
 	CuAssertPtrNotNull (tc, map);
-	if (!hash_set (map, &key, &value))
+	if (!_p11_hash_set (map, &key, &value))
 		CuFail (tc, "should not be reached");
 
-	ret = hash_set (map, &key, &value2);
+	ret = _p11_hash_set (map, &key, &value2);
 	CuAssertIntEquals (tc, ret, 1);
 	CuAssertIntEquals (tc, 0, key);
 	CuAssertIntEquals (tc, 2, value);
@@ -246,7 +246,7 @@ test_hash_set_destroys (CuTest *tc)
 	value = 0;
 	value2 = 0;
 
-	hash_free (map);
+	_p11_hash_free (map);
 
 	CuAssertIntEquals (tc, 1, key);
 	CuAssertIntEquals (tc, 0, value);
@@ -255,18 +255,18 @@ test_hash_set_destroys (CuTest *tc)
 
 
 static void
-test_hash_clear_destroys (CuTest *tc)
+test__p11_hash_clear_destroys (CuTest *tc)
 {
 	hashmap *map;
 	int key = 0;
 	int value = 0;
 
-	map = hash_create (hash_direct_hash, hash_direct_equal, destroy_key, destroy_value);
+	map = _p11_hash_create (_p11_hash_direct_hash, _p11_hash_direct_equal, destroy_key, destroy_value);
 	CuAssertPtrNotNull (tc, map);
-	if (!hash_set (map, &key, &value))
+	if (!_p11_hash_set (map, &key, &value))
 		CuFail (tc, "should not be reached");
 
-	hash_clear (map);
+	_p11_hash_clear (map);
 	CuAssertIntEquals (tc, 1, key);
 	CuAssertIntEquals (tc, 2, value);
 
@@ -274,7 +274,7 @@ test_hash_clear_destroys (CuTest *tc)
 	key = 0;
 	value = 0;
 
-	hash_clear (map);
+	_p11_hash_clear (map);
 	CuAssertIntEquals (tc, 0, key);
 	CuAssertIntEquals (tc, 0, value);
 
@@ -282,7 +282,7 @@ test_hash_clear_destroys (CuTest *tc)
 	key = 0;
 	value = 0;
 
-	hash_free (map);
+	_p11_hash_free (map);
 
 	CuAssertIntEquals (tc, 0, key);
 	CuAssertIntEquals (tc, 0, value);
@@ -302,23 +302,23 @@ test_hash_add_check_lots_and_collisions (CuTest *tc)
 	int *value;
 	int i;
 
-	map = hash_create (test_hash_intptr_with_collisions,
-	                  hash_intptr_equal, NULL, free);
+	map = _p11_hash_create (test_hash_intptr_with_collisions,
+	                  _p11_hash_intptr_equal, NULL, free);
 
 	for (i = 0; i < 20000; ++i) {
 		value = malloc (sizeof (int));
 		*value = i;
-		if (!hash_set (map, value, value))
+		if (!_p11_hash_set (map, value, value))
 			CuFail (tc, "should not be reached");
 	}
 
 	for (i = 0; i < 20000; ++i) {
-		value = hash_get (map, &i);
+		value = _p11_hash_get (map, &i);
 		CuAssertPtrNotNull (tc, value);
 		CuAssertIntEquals (tc, i, *value);
 	}
 
-	hash_free (map);
+	_p11_hash_free (map);
 }
 
 static void
@@ -328,28 +328,28 @@ test_hash_count (CuTest *tc)
 	int *value;
 	int i, ret;
 
-	map = hash_create (hash_intptr_hash, hash_intptr_equal, NULL, free);
+	map = _p11_hash_create (_p11_hash_intptr_hash, _p11_hash_intptr_equal, NULL, free);
 
-	CuAssertIntEquals (tc, 0, hash_size (map));
+	CuAssertIntEquals (tc, 0, _p11_hash_size (map));
 
 	for (i = 0; i < 20000; ++i) {
 		value = malloc (sizeof (int));
 		*value = i;
-		if (!hash_set (map, value, value))
+		if (!_p11_hash_set (map, value, value))
 			CuFail (tc, "should not be reached");
-		CuAssertIntEquals (tc, i + 1, hash_size (map));
+		CuAssertIntEquals (tc, i + 1, _p11_hash_size (map));
 	}
 
 	for (i = 0; i < 20000; ++i) {
-		ret = hash_remove (map, &i);
+		ret = _p11_hash_remove (map, &i);
 		CuAssertIntEquals (tc, 1, ret);
-		CuAssertIntEquals (tc, 20000 - (i + 1), hash_size (map));
+		CuAssertIntEquals (tc, 20000 - (i + 1), _p11_hash_size (map));
 	}
 
-	hash_clear (map);
-	CuAssertIntEquals (tc, 0, hash_size (map));
+	_p11_hash_clear (map);
+	CuAssertIntEquals (tc, 0, _p11_hash_size (map));
 
-	hash_free (map);
+	_p11_hash_free (map);
 }
 
 static void
@@ -359,22 +359,22 @@ test_hash_ulongptr (CuTest *tc)
 	unsigned long *value;
 	unsigned long i;
 
-	map = hash_create (hash_ulongptr_hash, hash_ulongptr_equal, NULL, free);
+	map = _p11_hash_create (_p11_hash_ulongptr_hash, _p11_hash_ulongptr_equal, NULL, free);
 
 	for (i = 0; i < 20000; ++i) {
 		value = malloc (sizeof (unsigned long));
 		*value = i;
-		if (!hash_set (map, value, value))
+		if (!_p11_hash_set (map, value, value))
 			CuFail (tc, "should not be reached");
 	}
 
 	for (i = 0; i < 20000; ++i) {
-		value = hash_get (map, &i);
+		value = _p11_hash_get (map, &i);
 		CuAssertPtrNotNull (tc, value);
 		CuAssertIntEquals (tc, i, *value);
 	}
 
-	hash_free (map);
+	_p11_hash_free (map);
 }
 
 int
@@ -384,16 +384,16 @@ main (void)
 	CuSuite* suite = CuSuiteNew ();
 	int ret;
 
-	SUITE_ADD_TEST (suite, test_hash_create);
-	SUITE_ADD_TEST (suite, test_hash_set_get);
-	SUITE_ADD_TEST (suite, test_hash_set_get_remove);
-	SUITE_ADD_TEST (suite, test_hash_remove_destroys);
-	SUITE_ADD_TEST (suite, test_hash_set_get_clear);
-	SUITE_ADD_TEST (suite, test_hash_set_destroys);
-	SUITE_ADD_TEST (suite, test_hash_clear_destroys);
-	SUITE_ADD_TEST (suite, test_hash_free_null);
-	SUITE_ADD_TEST (suite, test_hash_free_destroys);
-	SUITE_ADD_TEST (suite, test_hash_iterate);
+	SUITE_ADD_TEST (suite, test__p11_hash_create);
+	SUITE_ADD_TEST (suite, test__p11_hash_set_get);
+	SUITE_ADD_TEST (suite, test__p11_hash_set_get_remove);
+	SUITE_ADD_TEST (suite, test__p11_hash_remove_destroys);
+	SUITE_ADD_TEST (suite, test__p11_hash_set_get_clear);
+	SUITE_ADD_TEST (suite, test__p11_hash_set_destroys);
+	SUITE_ADD_TEST (suite, test__p11_hash_clear_destroys);
+	SUITE_ADD_TEST (suite, test__p11_hash_free_null);
+	SUITE_ADD_TEST (suite, test__p11_hash_free_destroys);
+	SUITE_ADD_TEST (suite, test__p11_hash_iterate);
 	SUITE_ADD_TEST (suite, test_hash_add_check_lots_and_collisions);
 	SUITE_ADD_TEST (suite, test_hash_count);
 	SUITE_ADD_TEST (suite, test_hash_ulongptr);
diff --git a/tests/mock-module.c b/tests/mock-module.c
index 1b7822a..9cb1831 100644
--- a/tests/mock-module.c
+++ b/tests/mock-module.c
@@ -97,7 +97,7 @@ mock_C_Initialize (CK_VOID_PTR init_args)
 
 	debug (("C_Initialize: enter"));
 
-	mutex_lock (&init_mutex);
+	_p11_mutex_lock (&init_mutex);
 
 		if (init_args != NULL) {
 			int supplied_ok;
@@ -148,7 +148,7 @@ done:
 			pkcs11_initialized_pid = 0;
 		}
 
-	mutex_unlock (&init_mutex);
+	_p11_mutex_unlock (&init_mutex);
 
 	debug (("C_Initialize: %d", ret));
 	return ret;
@@ -161,13 +161,13 @@ mock_C_Finalize (CK_VOID_PTR reserved)
 	return_val_if_fail (pkcs11_initialized != 0, CKR_CRYPTOKI_NOT_INITIALIZED);
 	return_val_if_fail (reserved == NULL, CKR_ARGUMENTS_BAD);
 
-	mutex_lock (&init_mutex);
+	_p11_mutex_lock (&init_mutex);
 
 		/* This should stop all other calls in */
 		pkcs11_initialized = 0;
 		pkcs11_initialized_pid = 0;
 
-	mutex_unlock (&init_mutex);
+	_p11_mutex_unlock (&init_mutex);
 
 	debug (("C_Finalize: %d", CKR_OK));
 	return CKR_OK;
@@ -890,5 +890,5 @@ CK_FUNCTION_LIST mock_module_no_slots = {
 void
 mock_module_init (void)
 {
-	mutex_init (&init_mutex);
+	_p11_mutex_init (&init_mutex);
 }
diff --git a/tests/ptr-array-test.c b/tests/ptr-array-test.c
index ff9959d..4eca468 100644
--- a/tests/ptr-array-test.c
+++ b/tests/ptr-array-test.c
@@ -42,19 +42,19 @@
 #include "ptr-array.h"
 
 static void
-test_ptr_array_create (CuTest *tc)
+test__p11_ptr_array_create (CuTest *tc)
 {
 	ptr_array_t *array;
 
-	array = ptr_array_create (NULL);
+	array = _p11_ptr_array_create (NULL);
 	CuAssertPtrNotNull (tc, array);
-	ptr_array_free (array);
+	_p11_ptr_array_free (array);
 }
 
 static void
-test_ptr_array_free_null (CuTest *tc)
+test__p11_ptr_array_free_null (CuTest *tc)
 {
-	ptr_array_free (NULL);
+	_p11_ptr_array_free (NULL);
 }
 
 static void
@@ -65,23 +65,23 @@ destroy_value (void *data)
 }
 
 static void
-test_ptr_array_free_destroys (CuTest *tc)
+test__p11_ptr_array_free_destroys (CuTest *tc)
 {
 	ptr_array_t *array;
 	int value = 0;
 
-	array = ptr_array_create (destroy_value);
+	array = _p11_ptr_array_create (destroy_value);
 	CuAssertPtrNotNull (tc, array);
-	if (!ptr_array_add (array, &value))
+	if (!_p11_ptr_array_add (array, &value))
 		CuFail (tc, "should not be reached");
-	ptr_array_free (array);
+	_p11_ptr_array_free (array);
 
 	CuAssertIntEquals (tc, 2, value);
 }
 
 #if 0
 static void
-test_hash_iterate (CuTest *tc)
+test__p11_hash_iterate (CuTest *tc)
 {
 	hash_t *ht;
 	hash_iter_t hi;
@@ -91,134 +91,134 @@ test_hash_iterate (CuTest *tc)
 	void *pvalue;
 	int ret;
 
-	ht = hash_create (hash_direct_hash, hash_direct_equal, NULL, NULL);
+	ht = _p11_hash_create (_p11_hash_direct_hash, _p11_hash_direct_equal, NULL, NULL);
 	CuAssertPtrNotNull (tc, ht);
-	if (!hash_set (ht, &key, &value))
+	if (!_p11_hash_set (ht, &key, &value))
 		CuFail (tc, "should not be reached");
 
-	hash_iterate (ht, &hi);
+	_p11_hash_iterate (ht, &hi);
 
-	ret = hash_next (&hi, &pkey, &pvalue);
+	ret = _p11_hash_next (&hi, &pkey, &pvalue);
 	CuAssertIntEquals (tc, 1, ret);
 	CuAssertPtrEquals (tc, pkey, &key);
 	CuAssertPtrEquals (tc, pvalue, &value);
 
-	ret = hash_next (&hi, &pkey, &pvalue);
+	ret = _p11_hash_next (&hi, &pkey, &pvalue);
 	CuAssertIntEquals (tc, 0, ret);
 
-	hash_free (ht);
+	_p11_hash_free (ht);
 }
 
 #endif
 
 static void
-test_ptr_array_add (CuTest *tc)
+test__p11_ptr_array_add (CuTest *tc)
 {
 	char *value = "VALUE";
 	char *check;
 	ptr_array_t *array;
 
-	array = ptr_array_create (NULL);
-	if (!ptr_array_add (array, value))
+	array = _p11_ptr_array_create (NULL);
+	if (!_p11_ptr_array_add (array, value))
 		CuFail (tc, "should not be reached");
 
-	CuAssertIntEquals (tc, 1, ptr_array_count (array));
+	CuAssertIntEquals (tc, 1, _p11_ptr_array_count (array));
 
-	check = ptr_array_at (array, 0);
+	check = _p11_ptr_array_at (array, 0);
 	CuAssertPtrEquals (tc, check, value);
 
-	ptr_array_free (array);
+	_p11_ptr_array_free (array);
 }
 
 static void
-test_ptr_array_add_remove (CuTest *tc)
+test__p11_ptr_array_add_remove (CuTest *tc)
 {
 	char *value = "VALUE";
 	char *check;
 	ptr_array_t *array;
 
-	array = ptr_array_create (NULL);
-	if (!ptr_array_add (array, value))
+	array = _p11_ptr_array_create (NULL);
+	if (!_p11_ptr_array_add (array, value))
 		CuFail (tc, "should not be reached");
 
-	CuAssertIntEquals (tc, 1, ptr_array_count (array));
+	CuAssertIntEquals (tc, 1, _p11_ptr_array_count (array));
 
-	check = ptr_array_at (array, 0);
+	check = _p11_ptr_array_at (array, 0);
 	CuAssertPtrEquals (tc, check, value);
 
-	ptr_array_remove (array, 0);
+	_p11_ptr_array_remove (array, 0);
 
-	CuAssertIntEquals (tc, 0, ptr_array_count (array));
+	CuAssertIntEquals (tc, 0, _p11_ptr_array_count (array));
 
-	ptr_array_free (array);
+	_p11_ptr_array_free (array);
 }
 
 static void
-test_ptr_array_remove_destroys (CuTest *tc)
+test__p11_ptr_array_remove_destroys (CuTest *tc)
 {
 	ptr_array_t *array;
 	int value = 0;
 
-	array = ptr_array_create (destroy_value);
-	if (!ptr_array_add (array, &value))
+	array = _p11_ptr_array_create (destroy_value);
+	if (!_p11_ptr_array_add (array, &value))
 		CuFail (tc, "should not be reached");
 
-	ptr_array_remove (array, 0);
+	_p11_ptr_array_remove (array, 0);
 
 	CuAssertIntEquals (tc, 2, value);
 
 	/* should not be destroyed again */
 	value = 0;
 
-	ptr_array_free (array);
+	_p11_ptr_array_free (array);
 
 	CuAssertIntEquals (tc, 0, value);
 }
 
 static void
-test_ptr_array_remove_and_count (CuTest *tc)
+test__p11_ptr_array_remove_and_count (CuTest *tc)
 {
 	ptr_array_t *array;
 	int *value;
 	int i;
 
-	array = ptr_array_create (free);
+	array = _p11_ptr_array_create (free);
 
-	CuAssertIntEquals (tc, 0, ptr_array_count (array));
+	CuAssertIntEquals (tc, 0, _p11_ptr_array_count (array));
 
 	for (i = 0; i < 20000; ++i) {
 		value = malloc (sizeof (int));
 		*value = i;
-		if (!ptr_array_add (array, value))
+		if (!_p11_ptr_array_add (array, value))
 			CuFail (tc, "should not be reached");
-		CuAssertIntEquals (tc, i + 1, ptr_array_count (array));
+		CuAssertIntEquals (tc, i + 1, _p11_ptr_array_count (array));
 	}
 
 	for (i = 10; i < 20000; ++i) {
-		ptr_array_remove (array, 10);
-		CuAssertIntEquals (tc, 20010 - (i + 1), ptr_array_count (array));
+		_p11_ptr_array_remove (array, 10);
+		CuAssertIntEquals (tc, 20010 - (i + 1), _p11_ptr_array_count (array));
 	}
 
-	CuAssertIntEquals (tc, 10, ptr_array_count (array));
+	CuAssertIntEquals (tc, 10, _p11_ptr_array_count (array));
 
-	ptr_array_free (array);
+	_p11_ptr_array_free (array);
 }
 
 static void
-test_ptr_array_snapshot (CuTest *tc)
+test__p11_ptr_array_snapshot (CuTest *tc)
 {
 	ptr_array_t *array;
 	void **snapshot;
 
-	array = ptr_array_create (NULL);
+	array = _p11_ptr_array_create (NULL);
 
-	ptr_array_add (array, "1");
-	ptr_array_add (array, "2");
-	ptr_array_add (array, "3");
-	ptr_array_add (array, "4");
-	CuAssertIntEquals (tc, 4, ptr_array_count (array));
+	_p11_ptr_array_add (array, "1");
+	_p11_ptr_array_add (array, "2");
+	_p11_ptr_array_add (array, "3");
+	_p11_ptr_array_add (array, "4");
+	CuAssertIntEquals (tc, 4, _p11_ptr_array_count (array));
 
-	snapshot = ptr_array_snapshot (array);
+	snapshot = _p11_ptr_array_snapshot (array);
 
 	CuAssertStrEquals (tc, "1", snapshot[0]);
 	CuAssertStrEquals (tc, "2", snapshot[1]);
@@ -226,7 +226,7 @@ test_ptr_array_snapshot (CuTest *tc)
 	CuAssertStrEquals (tc, "4", snapshot[3]);
 
 	free (snapshot);
-	ptr_array_free (array);
+	_p11_ptr_array_free (array);
 }
 
 int
@@ -236,14 +236,14 @@ main (void)
 	CuSuite* suite = CuSuiteNew ();
 	int ret;
 
-	SUITE_ADD_TEST (suite, test_ptr_array_create);
-	SUITE_ADD_TEST (suite, test_ptr_array_add);
-	SUITE_ADD_TEST (suite, test_ptr_array_add_remove);
-	SUITE_ADD_TEST (suite, test_ptr_array_remove_destroys);
-	SUITE_ADD_TEST (suite, test_ptr_array_remove_and_count);
-	SUITE_ADD_TEST (suite, test_ptr_array_free_null);
-	SUITE_ADD_TEST (suite, test_ptr_array_free_destroys);
-	SUITE_ADD_TEST (suite, test_ptr_array_snapshot);
+	SUITE_ADD_TEST (suite, test__p11_ptr_array_create);
+	SUITE_ADD_TEST (suite, test__p11_ptr_array_add);
+	SUITE_ADD_TEST (suite, test__p11_ptr_array_add_remove);
+	SUITE_ADD_TEST (suite, test__p11_ptr_array_remove_destroys);
+	SUITE_ADD_TEST (suite, test__p11_ptr_array_remove_and_count);
+	SUITE_ADD_TEST (suite, test__p11_ptr_array_free_null);
+	SUITE_ADD_TEST (suite, test__p11_ptr_array_free_destroys);
+	SUITE_ADD_TEST (suite, test__p11_ptr_array_snapshot);
 
 	CuSuiteRun (suite);
 	CuSuiteSummary (suite, output);
diff --git a/tests/test-init.c b/tests/test-init.c
index 8367f10..af07860 100644
--- a/tests/test-init.c
+++ b/tests/test-init.c
@@ -135,11 +135,11 @@ static CK_RV
 mock_C_Initialize__threaded_race (CK_VOID_PTR init_args)
 {
 	/* Atomically increment value */
-	mutex_lock (&race_mutex);
+	_p11_mutex_lock (&race_mutex);
 	initialization_count += 1;
-	mutex_unlock (&race_mutex);
+	_p11_mutex_unlock (&race_mutex);
 
-	sleep_ms (100);
+	_p11_sleep_ms (100);
 	return CKR_OK;
 }
 
@@ -147,11 +147,11 @@ static CK_RV
 mock_C_Finalize__threaded_race (CK_VOID_PTR reserved)
 {
 	/* Atomically increment value */
-	mutex_lock (&race_mutex);
+	_p11_mutex_lock (&race_mutex);
 	finalization_count += 1;
-	mutex_unlock (&race_mutex);
+	_p11_mutex_unlock (&race_mutex);
 
-	sleep_ms (100);
+	_p11_sleep_ms (100);
 	return CKR_OK;}
 
 static void *
@@ -195,25 +195,25 @@ test_threaded_initialization (CuTest *tc)
 	finalization_count = 0;
 
 	for (i = 0; i < num_threads; i++) {
-		ret = thread_create (&threads[i], initialization_thread, tc);
+		ret = _p11_thread_create (&threads[i], initialization_thread, tc);
 		CuAssertIntEquals (tc, 0, ret);
 		CuAssertTrue (tc, threads[i] != 0);
 	}
 
 	for (i = 0; i < num_threads; i++) {
-		ret = thread_join (threads[i]);
+		ret = _p11_thread_join (threads[i]);
 		CuAssertIntEquals (tc, 0, ret);
 		threads[i] = 0;
 	}
 
 	for (i = 0; i < num_threads; i++) {
-		ret = thread_create (&threads[i], finalization_thread, tc);
+		ret = _p11_thread_create (&threads[i], finalization_thread, tc);
 		CuAssertIntEquals (tc, 0, ret);
 		CuAssertTrue (tc, threads[i] != 0);
 	}
 
 	for (i = 0; i < num_threads; i++) {
-		ret = thread_join (threads[i]);
+		ret = _p11_thread_join (threads[i]);
 		CuAssertIntEquals (tc, 0, ret);
 		threads[i] = 0;
 	}
@@ -230,7 +230,7 @@ main (void)
 	CuSuite* suite = CuSuiteNew ();
 	int ret;
 
-	mutex_init (&race_mutex);
+	_p11_mutex_init (&race_mutex);
 	mock_module_init ();
 	_p11_library_init ();
 
diff --git a/tests/uri-test.c b/tests/uri-test.c
index 0e8c718..0d57835 100644
--- a/tests/uri-test.c
+++ b/tests/uri-test.c
@@ -40,7 +40,8 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "uri.h"
+#include "p11-kit/uri.h"
+#include "p11-kit/private.h"
 
 static int
 is_module_empty (P11KitUri *uri)
@@ -1159,6 +1160,8 @@ main (void)
 	CuSuite* suite = CuSuiteNew ();
 	int ret;
 
+	_p11_library_init ();
+
 	SUITE_ADD_TEST (suite, test_uri_parse);
 	SUITE_ADD_TEST (suite, test_uri_parse_bad_scheme);
 	SUITE_ADD_TEST (suite, test_uri_parse_with_label);