From 1e7b27c7b322476c437a8524cff4a88245c5efbf Mon Sep 17 00:00:00 2001 From: David Robillard Date: Fri, 29 Apr 2011 17:30:30 +0000 Subject: LilvValue => LilvNode. git-svn-id: http://svn.drobilla.net/lad/trunk/lilv@3234 a436a847-0d15-0410-975c-d299462d15a1 --- test/lilv_test.c | 522 +++++++++++++++++++++++++++---------------------------- 1 file changed, 261 insertions(+), 261 deletions(-) (limited to 'test') 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 " 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, "")); 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(); -- cgit v1.2.1