LilvValue => LilvNode.

git-svn-id: http://svn.drobilla.net/lad/trunk/lilv@3234 a436a847-0d15-0410-975c-d299462d15a1

1 files changed, 261 insertions, 261 deletions

diff --git a/test/lilv_test.c b/test/lilv_test.c
index 300184c..24c5f5b 100644
--- a/test/lilv_test.c
+++ b/test/lilv_test.c
@@ -162,8 +162,8 @@ struct TestCase {
 #define LICENSE_GPL "doap:license <http://usefulinc.com/doap/licenses/gpl>"
 
 static char *uris_plugin = "http://example.org/plug";
-static LilvValue* plugin_uri_value;
-static LilvValue* plugin2_uri_value;
+static LilvNode* plugin_uri_value;
+static LilvNode* plugin2_uri_value;
 
 /*****************************************************************************/
 
@@ -179,8 +179,8 @@ init_uris()
 void
 cleanup_uris()
 {
-	lilv_value_free(plugin2_uri_value);
-	lilv_value_free(plugin_uri_value);
+	lilv_node_free(plugin2_uri_value);
+	lilv_node_free(plugin_uri_value);
 	plugin2_uri_value = NULL;
 	plugin_uri_value = NULL;
 }
@@ -215,91 +215,91 @@ test_value()
 
 	init_uris();
 
-	LilvValue* uval = lilv_new_uri(world, "http://example.org");
-	LilvValue* sval = lilv_new_string(world, "Foo");
-	LilvValue* ival = lilv_new_int(world, 42);
-	LilvValue* fval = lilv_new_float(world, 1.6180);
+	LilvNode* uval = lilv_new_uri(world, "http://example.org");
+	LilvNode* sval = lilv_new_string(world, "Foo");
+	LilvNode* ival = lilv_new_int(world, 42);
+	LilvNode* fval = lilv_new_float(world, 1.6180);
 
-	TEST_ASSERT(lilv_value_is_uri(uval));
-	TEST_ASSERT(lilv_value_is_string(sval));
-	TEST_ASSERT(lilv_value_is_int(ival));
-	TEST_ASSERT(lilv_value_is_float(fval));
+	TEST_ASSERT(lilv_node_is_uri(uval));
+	TEST_ASSERT(lilv_node_is_string(sval));
+	TEST_ASSERT(lilv_node_is_int(ival));
+	TEST_ASSERT(lilv_node_is_float(fval));
 
-	TEST_ASSERT(!lilv_value_is_literal(uval));
-	TEST_ASSERT(lilv_value_is_literal(sval));
-	TEST_ASSERT(lilv_value_is_literal(ival));
-	TEST_ASSERT(lilv_value_is_literal(fval));
+	TEST_ASSERT(!lilv_node_is_literal(uval));
+	TEST_ASSERT(lilv_node_is_literal(sval));
+	TEST_ASSERT(lilv_node_is_literal(ival));
+	TEST_ASSERT(lilv_node_is_literal(fval));
 
-	TEST_ASSERT(!strcmp(lilv_value_as_uri(uval), "http://example.org"));
-	TEST_ASSERT(!strcmp(lilv_value_as_string(sval), "Foo"));
-	TEST_ASSERT(lilv_value_as_int(ival) == 42);
-	TEST_ASSERT(fabs(lilv_value_as_float(fval) - 1.6180) < FLT_EPSILON);
+	TEST_ASSERT(!strcmp(lilv_node_as_uri(uval), "http://example.org"));
+	TEST_ASSERT(!strcmp(lilv_node_as_string(sval), "Foo"));
+	TEST_ASSERT(lilv_node_as_int(ival) == 42);
+	TEST_ASSERT(fabs(lilv_node_as_float(fval) - 1.6180) < FLT_EPSILON);
 
-	char* tok = lilv_value_get_turtle_token(uval);
+	char* tok = lilv_node_get_turtle_token(uval);
 	TEST_ASSERT(!strcmp(tok, "<http://example.org>"));
 	free(tok);
-	tok = lilv_value_get_turtle_token(sval);
+	tok = lilv_node_get_turtle_token(sval);
 	TEST_ASSERT(!strcmp(tok, "Foo"));
 	free(tok);
-	tok = lilv_value_get_turtle_token(ival);
+	tok = lilv_node_get_turtle_token(ival);
 	TEST_ASSERT(!strcmp(tok, "42"));
 	free(tok);
-	tok = lilv_value_get_turtle_token(fval);
+	tok = lilv_node_get_turtle_token(fval);
 	TEST_ASSERT(!strncmp(tok, "1.6180", 6));
 	free(tok);
 
-	LilvValue* uval_e = lilv_new_uri(world, "http://example.org");
-	LilvValue* sval_e = lilv_new_string(world, "Foo");
-	LilvValue* ival_e = lilv_new_int(world, 42);
-	LilvValue* fval_e = lilv_new_float(world, 1.6180);
-	LilvValue* uval_ne = lilv_new_uri(world, "http://no-example.org");
-	LilvValue* sval_ne = lilv_new_string(world, "Bar");
-	LilvValue* ival_ne = lilv_new_int(world, 24);
-	LilvValue* fval_ne = lilv_new_float(world, 3.14159);
-
-	TEST_ASSERT(lilv_value_equals(uval, uval_e));
-	TEST_ASSERT(lilv_value_equals(sval, sval_e));
-	TEST_ASSERT(lilv_value_equals(ival, ival_e));
-	TEST_ASSERT(lilv_value_equals(fval, fval_e));
-
-	TEST_ASSERT(!lilv_value_equals(uval, uval_ne));
-	TEST_ASSERT(!lilv_value_equals(sval, sval_ne));
-	TEST_ASSERT(!lilv_value_equals(ival, ival_ne));
-	TEST_ASSERT(!lilv_value_equals(fval, fval_ne));
-
-	TEST_ASSERT(!lilv_value_equals(uval, sval));
-	TEST_ASSERT(!lilv_value_equals(sval, ival));
-	TEST_ASSERT(!lilv_value_equals(ival, fval));
-
-	LilvValue* uval_dup = lilv_value_duplicate(uval);
-	TEST_ASSERT(lilv_value_equals(uval, uval_dup));
-
-	LilvValue* ifval = lilv_new_float(world, 42.0);
-	TEST_ASSERT(!lilv_value_equals(ival, ifval));
-	lilv_value_free(ifval);
-
-	LilvValue* nil = NULL;
-	TEST_ASSERT(!lilv_value_equals(uval, nil));
-	TEST_ASSERT(!lilv_value_equals(nil, uval));
-	TEST_ASSERT(lilv_value_equals(nil, nil));
-
-	LilvValue* nil2 = lilv_value_duplicate(nil);
-	TEST_ASSERT(lilv_value_equals(nil, nil2));
-
-	lilv_value_free(uval);
-	lilv_value_free(sval);
-	lilv_value_free(ival);
-	lilv_value_free(fval);
-	lilv_value_free(uval_e);
-	lilv_value_free(sval_e);
-	lilv_value_free(ival_e);
-	lilv_value_free(fval_e);
-	lilv_value_free(uval_ne);
-	lilv_value_free(sval_ne);
-	lilv_value_free(ival_ne);
-	lilv_value_free(fval_ne);
-	lilv_value_free(uval_dup);
-	lilv_value_free(nil2);
+	LilvNode* uval_e = lilv_new_uri(world, "http://example.org");
+	LilvNode* sval_e = lilv_new_string(world, "Foo");
+	LilvNode* ival_e = lilv_new_int(world, 42);
+	LilvNode* fval_e = lilv_new_float(world, 1.6180);
+	LilvNode* uval_ne = lilv_new_uri(world, "http://no-example.org");
+	LilvNode* sval_ne = lilv_new_string(world, "Bar");
+	LilvNode* ival_ne = lilv_new_int(world, 24);
+	LilvNode* fval_ne = lilv_new_float(world, 3.14159);
+
+	TEST_ASSERT(lilv_node_equals(uval, uval_e));
+	TEST_ASSERT(lilv_node_equals(sval, sval_e));
+	TEST_ASSERT(lilv_node_equals(ival, ival_e));
+	TEST_ASSERT(lilv_node_equals(fval, fval_e));
+
+	TEST_ASSERT(!lilv_node_equals(uval, uval_ne));
+	TEST_ASSERT(!lilv_node_equals(sval, sval_ne));
+	TEST_ASSERT(!lilv_node_equals(ival, ival_ne));
+	TEST_ASSERT(!lilv_node_equals(fval, fval_ne));
+
+	TEST_ASSERT(!lilv_node_equals(uval, sval));
+	TEST_ASSERT(!lilv_node_equals(sval, ival));
+	TEST_ASSERT(!lilv_node_equals(ival, fval));
+
+	LilvNode* uval_dup = lilv_node_duplicate(uval);
+	TEST_ASSERT(lilv_node_equals(uval, uval_dup));
+
+	LilvNode* ifval = lilv_new_float(world, 42.0);
+	TEST_ASSERT(!lilv_node_equals(ival, ifval));
+	lilv_node_free(ifval);
+
+	LilvNode* nil = NULL;
+	TEST_ASSERT(!lilv_node_equals(uval, nil));
+	TEST_ASSERT(!lilv_node_equals(nil, uval));
+	TEST_ASSERT(lilv_node_equals(nil, nil));
+
+	LilvNode* nil2 = lilv_node_duplicate(nil);
+	TEST_ASSERT(lilv_node_equals(nil, nil2));
+
+	lilv_node_free(uval);
+	lilv_node_free(sval);
+	lilv_node_free(ival);
+	lilv_node_free(fval);
+	lilv_node_free(uval_e);
+	lilv_node_free(sval_e);
+	lilv_node_free(ival_e);
+	lilv_node_free(fval_e);
+	lilv_node_free(uval_ne);
+	lilv_node_free(sval_ne);
+	lilv_node_free(ival_ne);
+	lilv_node_free(fval_ne);
+	lilv_node_free(uval_dup);
+	lilv_node_free(nil2);
 
 	cleanup_uris();
 	return 1;
@@ -312,16 +312,16 @@ static int discovery_plugin_found = 0;
 static void
 discovery_verify_plugin(const LilvPlugin* plugin)
 {
-	const LilvValue* value = lilv_plugin_get_uri(plugin);
-	if (lilv_value_equals(value, plugin_uri_value)) {
-		const LilvValue* lib_uri = NULL;
-		TEST_ASSERT(!lilv_value_equals(value, plugin2_uri_value));
+	const LilvNode* value = lilv_plugin_get_uri(plugin);
+	if (lilv_node_equals(value, plugin_uri_value)) {
+		const LilvNode* lib_uri = NULL;
+		TEST_ASSERT(!lilv_node_equals(value, plugin2_uri_value));
 		discovery_plugin_found = 1;
 		lib_uri = lilv_plugin_get_library_uri(plugin);
 		TEST_ASSERT(lib_uri);
-		TEST_ASSERT(lilv_value_is_uri(lib_uri));
-		TEST_ASSERT(lilv_value_as_uri(lib_uri));
-		TEST_ASSERT(strstr(lilv_value_as_uri(lib_uri), "foo.so"));
+		TEST_ASSERT(lilv_node_is_uri(lib_uri));
+		TEST_ASSERT(lilv_node_as_uri(lib_uri));
+		TEST_ASSERT(strstr(lilv_node_as_uri(lib_uri), "foo.so"));
 		TEST_ASSERT(lilv_plugin_verify(plugin));
 	}
 }
@@ -350,9 +350,9 @@ test_discovery()
 	TEST_ASSERT(explug2 == NULL);
 
 	if (explug) {
-		LilvValue* name = lilv_plugin_get_name(explug);
-		TEST_ASSERT(!strcmp(lilv_value_as_string(name), "Test plugin"));
-		lilv_value_free(name);
+		LilvNode* name = lilv_plugin_get_name(explug);
+		TEST_ASSERT(!strcmp(lilv_node_as_string(name), "Test plugin"));
+		lilv_node_free(name);
 	}
 
 	discovery_plugin_found = 0;
@@ -435,19 +435,19 @@ test_classes()
 
 	TEST_ASSERT(lilv_plugin_class_get_parent_uri(plugin) == NULL);
 	TEST_ASSERT(lilv_plugin_classes_size(classes) > lilv_plugin_classes_size(children));
-	TEST_ASSERT(!strcmp(lilv_value_as_string(lilv_plugin_class_get_label(plugin)), "Plugin"));
-	TEST_ASSERT(!strcmp(lilv_value_as_string(lilv_plugin_class_get_uri(plugin)),
+	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_plugin_class_get_label(plugin)), "Plugin"));
+	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_plugin_class_get_uri(plugin)),
 			"http://lv2plug.in/ns/lv2core#Plugin"));
 
 	LILV_FOREACH(plugin_classes, i, children) {
-		TEST_ASSERT(lilv_value_equals(
+		TEST_ASSERT(lilv_node_equals(
 				lilv_plugin_class_get_parent_uri(lilv_plugin_classes_get(children, i)),
 				lilv_plugin_class_get_uri(plugin)));
 	}
 
-	LilvValue* some_uri = lilv_new_uri(world, "http://example.org/whatever");
+	LilvNode* some_uri = lilv_new_uri(world, "http://example.org/whatever");
 	TEST_ASSERT(lilv_plugin_classes_get_by_uri(classes, some_uri) == NULL);
-	lilv_value_free(some_uri);
+	lilv_node_free(some_uri);
 
 	lilv_plugin_classes_free(children);
 
@@ -495,30 +495,30 @@ test_plugin()
 	TEST_ASSERT(plug);
 
 	const LilvPluginClass* class = lilv_plugin_get_class(plug);
-	const LilvValue* class_uri = lilv_plugin_class_get_uri(class);
-	TEST_ASSERT(!strcmp(lilv_value_as_string(class_uri),
+	const LilvNode* class_uri = lilv_plugin_class_get_uri(class);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(class_uri),
 			"http://lv2plug.in/ns/lv2core#CompressorPlugin"));
 
-	const LilvValue* plug_bundle_uri = lilv_plugin_get_bundle_uri(plug);
-	TEST_ASSERT(!strcmp(lilv_value_as_string(plug_bundle_uri), bundle_dir_uri));
+	const LilvNode* plug_bundle_uri = lilv_plugin_get_bundle_uri(plug);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(plug_bundle_uri), bundle_dir_uri));
 
-	const LilvValues* data_uris = lilv_plugin_get_data_uris(plug);
-	TEST_ASSERT(lilv_values_size(data_uris) == 2);
+	const LilvNodes* data_uris = lilv_plugin_get_data_uris(plug);
+	TEST_ASSERT(lilv_nodes_size(data_uris) == 2);
 
 	char* manifest_uri = (char*)malloc(TEST_PATH_MAX);
 	char* data_uri     = (char*)malloc(TEST_PATH_MAX);
 	snprintf(manifest_uri, TEST_PATH_MAX, "%s%s",
-			lilv_value_as_string(plug_bundle_uri), "manifest.ttl");
+			lilv_node_as_string(plug_bundle_uri), "manifest.ttl");
 	snprintf(data_uri, TEST_PATH_MAX, "%s%s",
-			lilv_value_as_string(plug_bundle_uri), "plugin.ttl");
+			lilv_node_as_string(plug_bundle_uri), "plugin.ttl");
 
-	LilvValue* manifest_uri_val = lilv_new_uri(world, manifest_uri);
-	TEST_ASSERT(lilv_values_contains(data_uris, manifest_uri_val));
-	lilv_value_free(manifest_uri_val);
+	LilvNode* manifest_uri_val = lilv_new_uri(world, manifest_uri);
+	TEST_ASSERT(lilv_nodes_contains(data_uris, manifest_uri_val));
+	lilv_node_free(manifest_uri_val);
 
-	LilvValue* data_uri_val = lilv_new_uri(world, data_uri);
-	TEST_ASSERT(lilv_values_contains(data_uris, data_uri_val));
-	lilv_value_free(data_uri_val);
+	LilvNode* data_uri_val = lilv_new_uri(world, data_uri);
+	TEST_ASSERT(lilv_nodes_contains(data_uris, data_uri_val));
+	lilv_node_free(data_uri_val);
 
 	free(manifest_uri);
 	free(data_uri);
@@ -531,13 +531,13 @@ test_plugin()
 	TEST_ASSERT(maxs[0] == 1.0f);
 	TEST_ASSERT(defs[0] == 0.5f);
 
-	LilvValue* audio_class = lilv_new_uri(world,
+	LilvNode* audio_class = lilv_new_uri(world,
 			"http://lv2plug.in/ns/lv2core#AudioPort");
-	LilvValue* control_class = lilv_new_uri(world,
+	LilvNode* control_class = lilv_new_uri(world,
 			"http://lv2plug.in/ns/lv2core#ControlPort");
-	LilvValue* in_class = lilv_new_uri(world,
+	LilvNode* in_class = lilv_new_uri(world,
 			"http://lv2plug.in/ns/lv2core#InputPort");
-	LilvValue* out_class = lilv_new_uri(world,
+	LilvNode* out_class = lilv_new_uri(world,
 			"http://lv2plug.in/ns/lv2core#OutputPort");
 
 	TEST_ASSERT(lilv_plugin_get_num_ports_of_class(plug, control_class, NULL) == 3);
@@ -552,84 +552,84 @@ test_plugin()
 	TEST_ASSERT(lilv_plugin_has_latency(plug));
 	TEST_ASSERT(lilv_plugin_get_latency_port_index(plug) == 2);
 
-	LilvValue* rt_feature = lilv_new_uri(world,
+	LilvNode* rt_feature = lilv_new_uri(world,
 			"http://lv2plug.in/ns/lv2core#hardRTCapable");
-	LilvValue* event_feature = lilv_new_uri(world,
+	LilvNode* event_feature = lilv_new_uri(world,
 			"http://lv2plug.in/ns/ext/event");
-	LilvValue* pretend_feature = lilv_new_uri(world,
+	LilvNode* pretend_feature = lilv_new_uri(world,
 			"http://example.org/solvesWorldHunger");
 
 	TEST_ASSERT(lilv_plugin_has_feature(plug, rt_feature));
 	TEST_ASSERT(lilv_plugin_has_feature(plug, event_feature));
 	TEST_ASSERT(!lilv_plugin_has_feature(plug, pretend_feature));
 
-	lilv_value_free(rt_feature);
-	lilv_value_free(event_feature);
-	lilv_value_free(pretend_feature);
-
-	LilvValues* supported = lilv_plugin_get_supported_features(plug);
-	LilvValues* required = lilv_plugin_get_required_features(plug);
-	LilvValues* optional = lilv_plugin_get_optional_features(plug);
-	TEST_ASSERT(lilv_values_size(supported) == 2);
-	TEST_ASSERT(lilv_values_size(required) == 1);
-	TEST_ASSERT(lilv_values_size(optional) == 1);
-	lilv_values_free(supported);
-	lilv_values_free(required);
-	lilv_values_free(optional);
-
-	LilvValue*  foo_p = lilv_new_uri(world, "http://example.org/foo");
-	LilvValues* foos  = lilv_plugin_get_value(plug, foo_p);
-	TEST_ASSERT(lilv_values_size(foos) == 1);
-	TEST_ASSERT(fabs(lilv_value_as_float(lilv_values_get_first(foos)) - 1.6180) < FLT_EPSILON);
-	lilv_value_free(foo_p);
-	lilv_values_free(foos);
-
-	LilvValue*  bar_p = lilv_new_uri(world, "http://example.org/bar");
-	LilvValues* bars  = lilv_plugin_get_value(plug, bar_p);
-	TEST_ASSERT(lilv_values_size(bars) == 1);
-	TEST_ASSERT(lilv_value_as_bool(lilv_values_get_first(bars)) == true);
-	lilv_value_free(bar_p);
-	lilv_values_free(bars);
-
-	LilvValue*  baz_p = lilv_new_uri(world, "http://example.org/baz");
-	LilvValues* bazs  = lilv_plugin_get_value(plug, baz_p);
-	TEST_ASSERT(lilv_values_size(bazs) == 1);
-	TEST_ASSERT(lilv_value_as_bool(lilv_values_get_first(bazs)) == false);
-	lilv_value_free(baz_p);
-	lilv_values_free(bazs);
-
-	LilvValue* author_name = lilv_plugin_get_author_name(plug);
-	TEST_ASSERT(!strcmp(lilv_value_as_string(author_name), "David Robillard"));
-	lilv_value_free(author_name);
-
-	LilvValue* author_email = lilv_plugin_get_author_email(plug);
-	TEST_ASSERT(!strcmp(lilv_value_as_string(author_email), "mailto:d@drobilla.net"));
-	lilv_value_free(author_email);
-
-	LilvValue* author_homepage = lilv_plugin_get_author_homepage(plug);
-	TEST_ASSERT(!strcmp(lilv_value_as_string(author_homepage), "http://drobilla.net"));
-	lilv_value_free(author_homepage);
-
-	LilvValue* thing_uri = lilv_new_uri(world, "http://example.org/thing");
-	LilvValue* name_p = lilv_new_uri(world, "http://usefulinc.com/ns/doap#name");
-	LilvValues* thing_names = lilv_plugin_get_value_for_subject(plug, thing_uri, name_p);
-	TEST_ASSERT(lilv_values_size(thing_names) == 1);
-	LilvValue* thing_name = lilv_values_get_first(thing_names);
+	lilv_node_free(rt_feature);
+	lilv_node_free(event_feature);
+	lilv_node_free(pretend_feature);
+
+	LilvNodes* supported = lilv_plugin_get_supported_features(plug);
+	LilvNodes* required = lilv_plugin_get_required_features(plug);
+	LilvNodes* optional = lilv_plugin_get_optional_features(plug);
+	TEST_ASSERT(lilv_nodes_size(supported) == 2);
+	TEST_ASSERT(lilv_nodes_size(required) == 1);
+	TEST_ASSERT(lilv_nodes_size(optional) == 1);
+	lilv_nodes_free(supported);
+	lilv_nodes_free(required);
+	lilv_nodes_free(optional);
+
+	LilvNode*  foo_p = lilv_new_uri(world, "http://example.org/foo");
+	LilvNodes* foos  = lilv_plugin_get_value(plug, foo_p);
+	TEST_ASSERT(lilv_nodes_size(foos) == 1);
+	TEST_ASSERT(fabs(lilv_node_as_float(lilv_nodes_get_first(foos)) - 1.6180) < FLT_EPSILON);
+	lilv_node_free(foo_p);
+	lilv_nodes_free(foos);
+
+	LilvNode*  bar_p = lilv_new_uri(world, "http://example.org/bar");
+	LilvNodes* bars  = lilv_plugin_get_value(plug, bar_p);
+	TEST_ASSERT(lilv_nodes_size(bars) == 1);
+	TEST_ASSERT(lilv_node_as_bool(lilv_nodes_get_first(bars)) == true);
+	lilv_node_free(bar_p);
+	lilv_nodes_free(bars);
+
+	LilvNode*  baz_p = lilv_new_uri(world, "http://example.org/baz");
+	LilvNodes* bazs  = lilv_plugin_get_value(plug, baz_p);
+	TEST_ASSERT(lilv_nodes_size(bazs) == 1);
+	TEST_ASSERT(lilv_node_as_bool(lilv_nodes_get_first(bazs)) == false);
+	lilv_node_free(baz_p);
+	lilv_nodes_free(bazs);
+
+	LilvNode* author_name = lilv_plugin_get_author_name(plug);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(author_name), "David Robillard"));
+	lilv_node_free(author_name);
+
+	LilvNode* author_email = lilv_plugin_get_author_email(plug);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(author_email), "mailto:d@drobilla.net"));
+	lilv_node_free(author_email);
+
+	LilvNode* author_homepage = lilv_plugin_get_author_homepage(plug);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(author_homepage), "http://drobilla.net"));
+	lilv_node_free(author_homepage);
+
+	LilvNode* thing_uri = lilv_new_uri(world, "http://example.org/thing");
+	LilvNode* name_p = lilv_new_uri(world, "http://usefulinc.com/ns/doap#name");
+	LilvNodes* thing_names = lilv_plugin_get_value_for_subject(plug, thing_uri, name_p);
+	TEST_ASSERT(lilv_nodes_size(thing_names) == 1);
+	LilvNode* thing_name = lilv_nodes_get_first(thing_names);
 	TEST_ASSERT(thing_name);
-	TEST_ASSERT(lilv_value_is_string(thing_name));
-	TEST_ASSERT(!strcmp(lilv_value_as_string(thing_name), "Something else"));
+	TEST_ASSERT(lilv_node_is_string(thing_name));
+	TEST_ASSERT(!strcmp(lilv_node_as_string(thing_name), "Something else"));
 
 	LilvUIs* uis = lilv_plugin_get_uis(plug);
 	TEST_ASSERT(lilv_uis_size(uis) == 0);
 	lilv_uis_free(uis);
 
-	lilv_values_free(thing_names);
-	lilv_value_free(thing_uri);
-	lilv_value_free(name_p);
-	lilv_value_free(control_class);
-	lilv_value_free(audio_class);
-	lilv_value_free(in_class);
-	lilv_value_free(out_class);
+	lilv_nodes_free(thing_names);
+	lilv_node_free(thing_uri);
+	lilv_node_free(name_p);
+	lilv_node_free(control_class);
+	lilv_node_free(audio_class);
+	lilv_node_free(in_class);
+	lilv_node_free(out_class);
 	cleanup_uris();
 	return 1;
 }
@@ -669,66 +669,66 @@ test_port()
 	const LilvPlugin* plug = lilv_plugins_get_by_uri(plugins, plugin_uri_value);
 	TEST_ASSERT(plug);
 
-	LilvValue* psym = lilv_new_string(world, "foo");
+	LilvNode* psym = lilv_new_string(world, "foo");
 	const LilvPort*  p    = lilv_plugin_get_port_by_index(plug, 0);
 	const LilvPort*  p2   = lilv_plugin_get_port_by_symbol(plug, psym);
-	lilv_value_free(psym);
+	lilv_node_free(psym);
 	TEST_ASSERT(p != NULL);
 	TEST_ASSERT(p2 != NULL);
 	TEST_ASSERT(p == p2);
 
-	LilvValue*      nopsym = lilv_new_string(world, "thisaintnoportfoo");
+	LilvNode*      nopsym = lilv_new_string(world, "thisaintnoportfoo");
 	const LilvPort* p3     = lilv_plugin_get_port_by_symbol(plug, nopsym);
 	TEST_ASSERT(p3 == NULL);
-	lilv_value_free(nopsym);
+	lilv_node_free(nopsym);
 
-	LilvValue* audio_class = lilv_new_uri(world,
+	LilvNode* audio_class = lilv_new_uri(world,
 			"http://lv2plug.in/ns/lv2core#AudioPort");
-	LilvValue* control_class = lilv_new_uri(world,
+	LilvNode* control_class = lilv_new_uri(world,
 			"http://lv2plug.in/ns/lv2core#ControlPort");
-	LilvValue* in_class = lilv_new_uri(world,
+	LilvNode* in_class = lilv_new_uri(world,
 			"http://lv2plug.in/ns/lv2core#InputPort");
 
-	TEST_ASSERT(lilv_values_size(lilv_port_get_classes(plug, p)) == 2);
+	TEST_ASSERT(lilv_nodes_size(lilv_port_get_classes(plug, p)) == 2);
 	TEST_ASSERT(lilv_plugin_get_num_ports(plug) == 2);
 	TEST_ASSERT(lilv_port_is_a(plug, p, control_class));
 	TEST_ASSERT(lilv_port_is_a(plug, p, in_class));
 	TEST_ASSERT(!lilv_port_is_a(plug, p, audio_class));
 
-	LilvValues* port_properties = lilv_port_get_properties(plug, p);
-	TEST_ASSERT(lilv_values_size(port_properties) == 1);
-	lilv_values_free(port_properties);
+	LilvNodes* port_properties = lilv_port_get_properties(plug, p);
+	TEST_ASSERT(lilv_nodes_size(port_properties) == 1);
+	lilv_nodes_free(port_properties);
 
 	// Untranslated name (current locale is set to "C" in main)
-	TEST_ASSERT(!strcmp(lilv_value_as_string(lilv_port_get_symbol(plug, p)), "foo"));
-	LilvValue* name = lilv_port_get_name(plug, p);
-	TEST_ASSERT(!strcmp(lilv_value_as_string(name), "store"));
-	lilv_value_free(name);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_port_get_symbol(plug, p)), "foo"));
+	LilvNode* name = lilv_port_get_name(plug, p);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(name), "store"));
+	lilv_node_free(name);
 
 	// Exact language match
 	setenv("LANG", "fr_FR", 1);
 	name = lilv_port_get_name(plug, p);
-	TEST_ASSERT(!strcmp(lilv_value_as_string(name), "épicerie"));
-	lilv_value_free(name);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(name), "épicerie"));
+	lilv_node_free(name);
 
 	// Exact language match (with charset suffix)
 	setenv("LANG", "fr_CA.utf8", 1);
 	name = lilv_port_get_name(plug, p);
-	TEST_ASSERT(!strcmp(lilv_value_as_string(name), "dépanneur"));
-	lilv_value_free(name);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(name), "dépanneur"));
+	lilv_node_free(name);
 
 	// Partial language match (choose value translated for different country)
 	setenv("LANG", "fr_BE", 1);
 	name = lilv_port_get_name(plug, p);
-	TEST_ASSERT((!strcmp(lilv_value_as_string(name), "dépanneur"))
-	            ||(!strcmp(lilv_value_as_string(name), "épicerie")));
-	lilv_value_free(name);
+	TEST_ASSERT((!strcmp(lilv_node_as_string(name), "dépanneur"))
+	            ||(!strcmp(lilv_node_as_string(name), "épicerie")));
+	lilv_node_free(name);
 
 	// Partial language match (choose country-less language tagged value)
 	setenv("LANG", "es_MX", 1);
 	name = lilv_port_get_name(plug, p);
-	TEST_ASSERT(!strcmp(lilv_value_as_string(name), "tienda"));
-	lilv_value_free(name);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(name), "tienda"));
+	lilv_node_free(name);
 
 	setenv("LANG", "C", 1);  // Reset locale
 
@@ -742,81 +742,81 @@ test_port()
 	const LilvScalePoint* sp1 = lilv_scale_points_get(points, sp_iter);
 	TEST_ASSERT(sp1);
 
-	TEST_ASSERT(!strcmp(lilv_value_as_string(lilv_scale_point_get_label(sp0)), "Sin"));
-	TEST_ASSERT(lilv_value_as_float(lilv_scale_point_get_value(sp0)) == 3);
-	TEST_ASSERT(!strcmp(lilv_value_as_string(lilv_scale_point_get_label(sp1)), "Cos"));
-	TEST_ASSERT(lilv_value_as_float(lilv_scale_point_get_value(sp1)) == 4);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_scale_point_get_label(sp0)), "Sin"));
+	TEST_ASSERT(lilv_node_as_float(lilv_scale_point_get_value(sp0)) == 3);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_scale_point_get_label(sp1)), "Cos"));
+	TEST_ASSERT(lilv_node_as_float(lilv_scale_point_get_value(sp1)) == 4);
 
-	LilvValue* homepage_p = lilv_new_uri(world, "http://usefulinc.com/ns/doap#homepage");
-	LilvValues* homepages = lilv_plugin_get_value(plug, homepage_p);
-	TEST_ASSERT(lilv_values_size(homepages) == 1);
-	TEST_ASSERT(!strcmp(lilv_value_as_string(lilv_values_get_first(homepages)),
+	LilvNode* homepage_p = lilv_new_uri(world, "http://usefulinc.com/ns/doap#homepage");
+	LilvNodes* homepages = lilv_plugin_get_value(plug, homepage_p);
+	TEST_ASSERT(lilv_nodes_size(homepages) == 1);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_nodes_get_first(homepages)),
 			"http://example.org/someplug"));
 
-	LilvValue *min, *max, *def;
+	LilvNode *min, *max, *def;
 	lilv_port_get_range(plug, p, &def, &min, &max);
 	TEST_ASSERT(def);
 	TEST_ASSERT(min);
 	TEST_ASSERT(max);
-	TEST_ASSERT(lilv_value_as_float(def) == 0.5);
-	TEST_ASSERT(lilv_value_as_float(min) == -1.0);
-	TEST_ASSERT(lilv_value_as_float(max) == 1.0);
+	TEST_ASSERT(lilv_node_as_float(def) == 0.5);
+	TEST_ASSERT(lilv_node_as_float(min) == -1.0);
+	TEST_ASSERT(lilv_node_as_float(max) == 1.0);
 
-	LilvValue* integer_prop = lilv_new_uri(world, "http://lv2plug.in/ns/lv2core#integer");
-	LilvValue* toggled_prop = lilv_new_uri(world, "http://lv2plug.in/ns/lv2core#toggled");
+	LilvNode* integer_prop = lilv_new_uri(world, "http://lv2plug.in/ns/lv2core#integer");
+	LilvNode* toggled_prop = lilv_new_uri(world, "http://lv2plug.in/ns/lv2core#toggled");
 
 	TEST_ASSERT(lilv_port_has_property(plug, p, integer_prop));
 	TEST_ASSERT(!lilv_port_has_property(plug, p, toggled_prop));
 
 	const LilvPort* ep = lilv_plugin_get_port_by_index(plug, 1);
 
-	LilvValue* event_type = lilv_new_uri(world, "http://example.org/event");
-	LilvValue* event_type_2 = lilv_new_uri(world, "http://example.org/otherEvent");
+	LilvNode* event_type = lilv_new_uri(world, "http://example.org/event");
+	LilvNode* event_type_2 = lilv_new_uri(world, "http://example.org/otherEvent");
 	TEST_ASSERT(lilv_port_supports_event(plug, ep, event_type));
 	TEST_ASSERT(!lilv_port_supports_event(plug, ep, event_type_2));
 
-	LilvValue* name_p = lilv_new_uri(world, "http://lv2plug.in/ns/lv2core#name");
-	LilvValues* names = lilv_port_get_value(plug, p, name_p);
-	TEST_ASSERT(lilv_values_size(names) == 1);
-	TEST_ASSERT(!strcmp(lilv_value_as_string(lilv_values_get_first(names)),
+	LilvNode* name_p = lilv_new_uri(world, "http://lv2plug.in/ns/lv2core#name");
+	LilvNodes* names = lilv_port_get_value(plug, p, name_p);
+	TEST_ASSERT(lilv_nodes_size(names) == 1);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_nodes_get_first(names)),
 	                    "store"));
-	lilv_values_free(names);
+	lilv_nodes_free(names);
 
-	LilvValue* true_val  = lilv_new_bool(world, true);
-	LilvValue* false_val = lilv_new_bool(world, false);
+	LilvNode* true_val  = lilv_new_bool(world, true);
+	LilvNode* false_val = lilv_new_bool(world, false);
 
 	lilv_world_set_option(world, LILV_OPTION_FILTER_LANG, false_val);
 	names = lilv_port_get_value(plug, p, name_p);
-	TEST_ASSERT(lilv_values_size(names) == 4);
-	lilv_values_free(names);
+	TEST_ASSERT(lilv_nodes_size(names) == 4);
+	lilv_nodes_free(names);
 	lilv_world_set_option(world, LILV_OPTION_FILTER_LANG, true_val);
 
-	lilv_value_free(false_val);
-	lilv_value_free(true_val);
+	lilv_node_free(false_val);
+	lilv_node_free(true_val);
 
 	names = lilv_port_get_value(plug, ep, name_p);
-	TEST_ASSERT(lilv_values_size(names) == 1);
-	TEST_ASSERT(!strcmp(lilv_value_as_string(lilv_values_get_first(names)),
+	TEST_ASSERT(lilv_nodes_size(names) == 1);
+	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_nodes_get_first(names)),
 	                    "Event Input"));
-	lilv_values_free(names);
-	lilv_value_free(name_p);
+	lilv_nodes_free(names);
+	lilv_node_free(name_p);
 
-	lilv_value_free(integer_prop);
-	lilv_value_free(toggled_prop);
-	lilv_value_free(event_type);
-	lilv_value_free(event_type_2);
+	lilv_node_free(integer_prop);
+	lilv_node_free(toggled_prop);
+	lilv_node_free(event_type);
+	lilv_node_free(event_type_2);
 
-	lilv_value_free(min);
-	lilv_value_free(max);
-	lilv_value_free(def);
+	lilv_node_free(min);
+	lilv_node_free(max);
+	lilv_node_free(def);
 
-	lilv_value_free(homepage_p);
-	lilv_values_free(homepages);
+	lilv_node_free(homepage_p);
+	lilv_nodes_free(homepages);
 
 	lilv_scale_points_free(points);
-	lilv_value_free(control_class);
-	lilv_value_free(audio_class);
-	lilv_value_free(in_class);
+	lilv_node_free(control_class);
+	lilv_node_free(audio_class);
+	lilv_node_free(in_class);
 	cleanup_uris();
 	return 1;
 }
@@ -870,10 +870,10 @@ test_ui()
 	const LilvUI* ui0 = lilv_uis_get(uis, lilv_uis_begin(uis));
 	TEST_ASSERT(ui0);
 
-	LilvValue* ui_uri = lilv_new_uri(world, "http://example.org/ui");
-	LilvValue* ui2_uri = lilv_new_uri(world, "http://example.org/ui3");
-	LilvValue* ui3_uri = lilv_new_uri(world, "http://example.org/ui4");
-	LilvValue* noui_uri = lilv_new_uri(world, "http://example.org/notaui");
+	LilvNode* ui_uri = lilv_new_uri(world, "http://example.org/ui");
+	LilvNode* ui2_uri = lilv_new_uri(world, "http://example.org/ui3");
+	LilvNode* ui3_uri = lilv_new_uri(world, "http://example.org/ui4");
+	LilvNode* noui_uri = lilv_new_uri(world, "http://example.org/notaui");
 
 	const LilvUI* ui0_2 = lilv_uis_get_by_uri(uis, ui_uri);
 	TEST_ASSERT(ui0 == ui0_2);
@@ -887,35 +887,35 @@ test_ui()
 	const LilvUI* noui = lilv_uis_get_by_uri(uis, noui_uri);
 	TEST_ASSERT(noui == NULL);
 
-	const LilvValues* classes = lilv_ui_get_classes(ui0);
-	TEST_ASSERT(lilv_values_size(classes) == 1);
+	const LilvNodes* classes = lilv_ui_get_classes(ui0);
+	TEST_ASSERT(lilv_nodes_size(classes) == 1);
 
-	LilvValue* ui_class_uri = lilv_new_uri(world,
+	LilvNode* ui_class_uri = lilv_new_uri(world,
 			"http://lv2plug.in/ns/extensions/ui#GtkUI");
 
-	TEST_ASSERT(lilv_value_equals(lilv_values_get_first(classes), ui_class_uri));
+	TEST_ASSERT(lilv_node_equals(lilv_nodes_get_first(classes), ui_class_uri));
 	TEST_ASSERT(lilv_ui_is_a(ui0, ui_class_uri));
 
-	const LilvValue* plug_bundle_uri = lilv_plugin_get_bundle_uri(plug);
-	const LilvValue* ui_bundle_uri   = lilv_ui_get_bundle_uri(ui0);
-	TEST_ASSERT(lilv_value_equals(plug_bundle_uri, ui_bundle_uri));
+	const LilvNode* plug_bundle_uri = lilv_plugin_get_bundle_uri(plug);
+	const LilvNode* ui_bundle_uri   = lilv_ui_get_bundle_uri(ui0);
+	TEST_ASSERT(lilv_node_equals(plug_bundle_uri, ui_bundle_uri));
 
 	char* ui_binary_uri_str = (char*)malloc(TEST_PATH_MAX);
 	snprintf(ui_binary_uri_str, TEST_PATH_MAX, "%s%s",
-			lilv_value_as_string(plug_bundle_uri), "ui.so");
+			lilv_node_as_string(plug_bundle_uri), "ui.so");
 
-	const LilvValue* ui_binary_uri = lilv_ui_get_binary_uri(ui0);
+	const LilvNode* ui_binary_uri = lilv_ui_get_binary_uri(ui0);
 
-	LilvValue* expected_uri = lilv_new_uri(world, ui_binary_uri_str);
-	TEST_ASSERT(lilv_value_equals(expected_uri, ui_binary_uri));
+	LilvNode* expected_uri = lilv_new_uri(world, ui_binary_uri_str);
+	TEST_ASSERT(lilv_node_equals(expected_uri, ui_binary_uri));
 
 	free(ui_binary_uri_str);
-	lilv_value_free(ui_class_uri);
-	lilv_value_free(ui_uri);
-	lilv_value_free(ui2_uri);
-	lilv_value_free(ui3_uri);
-	lilv_value_free(noui_uri);
-	lilv_value_free(expected_uri);
+	lilv_node_free(ui_class_uri);
+	lilv_node_free(ui_uri);
+	lilv_node_free(ui2_uri);
+	lilv_node_free(ui3_uri);
+	lilv_node_free(noui_uri);
+	lilv_node_free(expected_uri);
 	lilv_uis_free(uis);
 
 	cleanup_uris();