1 : /* SLV2 Tests
2 : * Copyright (C) 2008-2009 Dave Robillard <http://drobilla.net>
3 : * Copyright (C) 2008 Krzysztof Foltman
4 : *
5 : * This library is free software; you can redistribute it and/or modify it
6 : * under the terms of the GNU General Public License as published by the Free
7 : * Software Foundation; either version 2 of the License, or (at your option)
8 : * any later version.
9 : *
10 : * This library is distributed in the hope that it will be useful, but WITHOUT
11 : * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 : * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
13 : * for more details.
14 : *
15 : * You should have received a copy of the GNU General Public License along
16 : * with this program; if not, write to the Free Software Foundation, Inc.,
17 : * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 : */
19 :
20 : #define _XOPEN_SOURCE 500
21 :
22 : #include <unistd.h>
23 : #include <string.h>
24 : #include <stdio.h>
25 : #include <stdlib.h>
26 : #include <assert.h>
27 : #include <librdf.h>
28 : #include <sys/stat.h>
29 : #include <limits.h>
30 : #include <float.h>
31 : #include <math.h>
32 : #include "slv2/slv2.h"
33 :
34 : #define TEST_PATH_MAX 1024
35 :
36 : static char bundle_dir_name[TEST_PATH_MAX];
37 : static char bundle_dir_uri[TEST_PATH_MAX];
38 : static char manifest_name[TEST_PATH_MAX];
39 : static char content_name[TEST_PATH_MAX];
40 :
41 : static SLV2World world;
42 :
43 : int test_count = 0;
44 : int error_count = 0;
45 :
46 : void
47 : delete_bundle()
48 52 : {
49 52 : unlink(content_name);
50 52 : unlink(manifest_name);
51 52 : rmdir(bundle_dir_name);
52 52 : }
53 :
54 : void
55 : init_tests()
56 4 : {
57 4 : strncpy(bundle_dir_name, getenv("HOME"), 900);
58 4 : strcat(bundle_dir_name, "/.lv2/slv2-test.lv2");
59 4 : sprintf(bundle_dir_uri, "file://%s/", bundle_dir_name);
60 4 : sprintf(manifest_name, "%s/manifest.ttl", bundle_dir_name);
61 4 : sprintf(content_name, "%s/plugin.ttl", bundle_dir_name);
62 :
63 4 : delete_bundle();
64 4 : }
65 :
66 : void
67 : fatal_error(const char *err, const char *arg)
68 0 : {
69 : /* TODO: possibly change to vfprintf later */
70 0 : fprintf(stderr, err, arg);
71 : /* IMHO, the bundle should be left in place after an error, for possible investigation */
72 : /* delete_bundle(); */
73 0 : exit(1);
74 : }
75 :
76 : void
77 : write_file(const char *name, const char *content)
78 72 : {
79 72 : FILE* f = fopen(name, "w");
80 72 : size_t len = strlen(content);
81 72 : if (fwrite(content, 1, len, f) != len)
82 0 : fatal_error("Cannot write file %s\n", name);
83 72 : fclose(f);
84 72 : }
85 :
86 : int
87 : init_world()
88 40 : {
89 40 : world = slv2_world_new();
90 40 : return world != NULL;
91 : }
92 :
93 : int
94 : load_all_bundles()
95 36 : {
96 36 : if (!init_world())
97 0 : return 0;
98 36 : slv2_world_load_all(world);
99 36 : return 1;
100 : }
101 :
102 : void
103 : create_bundle(char *manifest, char *content)
104 36 : {
105 36 : if (mkdir(bundle_dir_name, 0700))
106 0 : fatal_error("Cannot create directory %s\n", bundle_dir_name);
107 36 : write_file(manifest_name, manifest);
108 36 : write_file(content_name, content);
109 36 : }
110 :
111 : int
112 : start_bundle(char *manifest, char *content)
113 36 : {
114 36 : create_bundle(manifest, content);
115 36 : return load_all_bundles();
116 : }
117 :
118 : void
119 : unload_bundle()
120 44 : {
121 44 : if (world)
122 40 : slv2_world_free(world);
123 44 : world = NULL;
124 44 : }
125 :
126 : void
127 : cleanup()
128 48 : {
129 48 : delete_bundle();
130 48 : }
131 :
132 : /*****************************************************************************/
133 :
134 : #define TEST_CASE(name) { #name, test_##name }
135 : #define TEST_ASSERT(check) do {\
136 : test_count++;\
137 : if (!(check)) {\
138 : error_count++;\
139 : fprintf(stderr, "Failure at slv2_test.c:%d: %s\n", __LINE__, #check);\
140 : }\
141 : } while (0)
142 :
143 : typedef int (*TestFunc)();
144 :
145 : struct TestCase {
146 : const char *title;
147 : TestFunc func;
148 : };
149 :
150 : #define PREFIX_LINE "@prefix : <http://example.org/> .\n"
151 : #define PREFIX_LV2 "@prefix lv2: <http://lv2plug.in/ns/lv2core#> .\n"
152 : #define PREFIX_LV2EV "@prefix lv2ev: <http://lv2plug.in/ns/ext/event#> . \n"
153 : #define PREFIX_LV2UI "@prefix lv2ui: <http://lv2plug.in/ns/extensions/ui#> .\n"
154 : #define PREFIX_RDFS "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n"
155 : #define PREFIX_FOAF "@prefix foaf: <http://xmlns.com/foaf/0.1/> .\n"
156 : #define PREFIX_DOAP "@prefix doap: <http://usefulinc.com/ns/doap#> .\n"
157 :
158 : #define MANIFEST_PREFIXES PREFIX_LINE PREFIX_LV2 PREFIX_RDFS
159 : #define BUNDLE_PREFIXES PREFIX_LINE PREFIX_LV2 PREFIX_RDFS PREFIX_FOAF PREFIX_DOAP
160 : #define PLUGIN_NAME(name) "doap:name \"" name "\""
161 : #define LICENSE_GPL "doap:license <http://usefulinc.com/doap/licenses/gpl>"
162 :
163 : static char *uris_plugin = "http://example.org/plug";
164 : static SLV2Value plugin_uri_value, plugin2_uri_value;
165 :
166 : /*****************************************************************************/
167 :
168 : void
169 : init_uris()
170 36 : {
171 36 : plugin_uri_value = slv2_value_new_uri(world, uris_plugin);
172 36 : plugin2_uri_value = slv2_value_new_uri(world, "http://example.org/foobar");
173 36 : TEST_ASSERT(plugin_uri_value);
174 36 : TEST_ASSERT(plugin2_uri_value);
175 36 : }
176 :
177 : void
178 : cleanup_uris()
179 36 : {
180 36 : slv2_value_free(plugin2_uri_value);
181 36 : slv2_value_free(plugin_uri_value);
182 36 : plugin2_uri_value = NULL;
183 36 : plugin_uri_value = NULL;
184 36 : }
185 :
186 : /*****************************************************************************/
187 :
188 : int
189 : test_utils()
190 4 : {
191 4 : TEST_ASSERT(!strcmp(slv2_uri_to_path("file:///tmp/blah"), "/tmp/blah"));
192 4 : TEST_ASSERT(!slv2_uri_to_path("file:/example.org/blah"));
193 4 : TEST_ASSERT(!slv2_uri_to_path("http://example.org/blah"));
194 4 : return 1;
195 : }
196 :
197 : /*****************************************************************************/
198 :
199 : int
200 : test_value()
201 4 : {
202 4 : if (!start_bundle(MANIFEST_PREFIXES
203 : ":plug a lv2:Plugin ; lv2:binary <foo.so> ; rdfs:seeAlso <plugin.ttl> .\n",
204 : BUNDLE_PREFIXES
205 : ":plug a lv2:Plugin ; a lv2:CompressorPlugin ; "
206 : PLUGIN_NAME("Test plugin") " ; "
207 : LICENSE_GPL " ; "
208 : "lv2:port [ "
209 : " a lv2:ControlPort ; a lv2:InputPort ; "
210 : " lv2:index 0 ; lv2:symbol \"foo\" ; lv2:name \"Foo\" ; "
211 : "] ."))
212 0 : return 0;
213 :
214 4 : init_uris();
215 :
216 4 : SLV2Value uval = slv2_value_new_uri(world, "http://example.org");
217 4 : SLV2Value sval = slv2_value_new_string(world, "Foo");
218 4 : SLV2Value ival = slv2_value_new_int(world, 42);
219 4 : SLV2Value fval = slv2_value_new_float(world, 1.6180);
220 :
221 4 : TEST_ASSERT(slv2_value_is_uri(uval));
222 4 : TEST_ASSERT(slv2_value_is_string(sval));
223 4 : TEST_ASSERT(slv2_value_is_int(ival));
224 4 : TEST_ASSERT(slv2_value_is_float(fval));
225 :
226 4 : TEST_ASSERT(!slv2_value_is_literal(uval));
227 4 : TEST_ASSERT(slv2_value_is_literal(sval));
228 4 : TEST_ASSERT(slv2_value_is_literal(ival));
229 4 : TEST_ASSERT(slv2_value_is_literal(fval));
230 :
231 4 : TEST_ASSERT(!strcmp(slv2_value_as_uri(uval), "http://example.org"));
232 4 : TEST_ASSERT(!strcmp(slv2_value_as_string(sval), "Foo"));
233 4 : TEST_ASSERT(slv2_value_as_int(ival) == 42);
234 4 : TEST_ASSERT(fabs(slv2_value_as_float(fval) - 1.6180) < FLT_EPSILON);
235 :
236 4 : char* tok = slv2_value_get_turtle_token(uval);
237 4 : TEST_ASSERT(!strcmp(tok, "<http://example.org>"));
238 4 : free(tok);
239 4 : tok = slv2_value_get_turtle_token(sval);
240 4 : TEST_ASSERT(!strcmp(tok, "Foo"));
241 4 : free(tok);
242 4 : tok = slv2_value_get_turtle_token(ival);
243 4 : TEST_ASSERT(!strcmp(tok, "42"));
244 4 : free(tok);
245 4 : tok = slv2_value_get_turtle_token(fval);
246 4 : TEST_ASSERT(!strncmp(tok, "1.6180", 6));
247 4 : free(tok);
248 :
249 4 : SLV2Value uval_e = slv2_value_new_uri(world, "http://example.org");
250 4 : SLV2Value sval_e = slv2_value_new_string(world, "Foo");
251 4 : SLV2Value ival_e = slv2_value_new_int(world, 42);
252 4 : SLV2Value fval_e = slv2_value_new_float(world, 1.6180);
253 4 : SLV2Value uval_ne = slv2_value_new_uri(world, "http://no-example.org");
254 4 : SLV2Value sval_ne = slv2_value_new_string(world, "Bar");
255 4 : SLV2Value ival_ne = slv2_value_new_int(world, 24);
256 4 : SLV2Value fval_ne = slv2_value_new_float(world, 3.14159);
257 :
258 4 : TEST_ASSERT(slv2_value_equals(uval, uval_e));
259 4 : TEST_ASSERT(slv2_value_equals(sval, sval_e));
260 4 : TEST_ASSERT(slv2_value_equals(ival, ival_e));
261 4 : TEST_ASSERT(slv2_value_equals(fval, fval_e));
262 :
263 4 : TEST_ASSERT(!slv2_value_equals(uval, uval_ne));
264 4 : TEST_ASSERT(!slv2_value_equals(sval, sval_ne));
265 4 : TEST_ASSERT(!slv2_value_equals(ival, ival_ne));
266 4 : TEST_ASSERT(!slv2_value_equals(fval, fval_ne));
267 :
268 4 : TEST_ASSERT(!slv2_value_equals(uval, sval));
269 4 : TEST_ASSERT(!slv2_value_equals(sval, ival));
270 4 : TEST_ASSERT(!slv2_value_equals(ival, fval));
271 :
272 4 : SLV2Value uval_dup = slv2_value_duplicate(uval);
273 4 : TEST_ASSERT(slv2_value_equals(uval, uval_dup));
274 :
275 4 : SLV2Value ifval = slv2_value_new_float(world, 42.0);
276 4 : TEST_ASSERT(!slv2_value_equals(ival, ifval));
277 4 : slv2_value_free(ifval);
278 :
279 4 : SLV2Value nil = NULL;
280 4 : TEST_ASSERT(!slv2_value_equals(uval, nil));
281 4 : TEST_ASSERT(!slv2_value_equals(nil, uval));
282 4 : TEST_ASSERT(slv2_value_equals(nil, nil));
283 :
284 4 : SLV2Value nil2 = slv2_value_duplicate(nil);
285 4 : TEST_ASSERT(slv2_value_equals(nil, nil2));
286 :
287 4 : slv2_value_free(uval);
288 4 : slv2_value_free(sval);
289 4 : slv2_value_free(ival);
290 4 : slv2_value_free(fval);
291 4 : slv2_value_free(uval_e);
292 4 : slv2_value_free(sval_e);
293 4 : slv2_value_free(ival_e);
294 4 : slv2_value_free(fval_e);
295 4 : slv2_value_free(uval_ne);
296 4 : slv2_value_free(sval_ne);
297 4 : slv2_value_free(ival_ne);
298 4 : slv2_value_free(fval_ne);
299 4 : slv2_value_free(uval_dup);
300 4 : slv2_value_free(nil2);
301 :
302 4 : cleanup_uris();
303 4 : return 1;
304 : }
305 :
306 : /*****************************************************************************/
307 :
308 : int
309 : test_values()
310 4 : {
311 4 : init_world();
312 4 : SLV2Value v0 = slv2_value_new_uri(world, "http://example.org/");
313 4 : SLV2Values vs1 = slv2_values_new();
314 4 : TEST_ASSERT(vs1);
315 4 : TEST_ASSERT(!slv2_values_size(vs1));
316 4 : TEST_ASSERT(!slv2_values_contains(vs1, v0));
317 4 : slv2_values_free(vs1);
318 4 : slv2_value_free(v0);
319 4 : return 1;
320 : }
321 :
322 : /*****************************************************************************/
323 :
324 : static int discovery_plugin_found = 0;
325 :
326 : static bool
327 : discovery_plugin_filter_all(SLV2Plugin plugin)
328 1168 : {
329 1168 : return true;
330 : }
331 :
332 : static bool
333 : discovery_plugin_filter_none(SLV2Plugin plugin)
334 1168 : {
335 1168 : return false;
336 : }
337 :
338 : static bool
339 : discovery_plugin_filter_ours(SLV2Plugin plugin)
340 1168 : {
341 1168 : return slv2_value_equals(slv2_plugin_get_uri(plugin), plugin_uri_value);
342 : }
343 :
344 : static bool
345 : discovery_plugin_filter_fake(SLV2Plugin plugin)
346 1168 : {
347 1168 : return slv2_value_equals(slv2_plugin_get_uri(plugin), plugin2_uri_value);
348 : }
349 :
350 : static void
351 : discovery_verify_plugin(SLV2Plugin plugin)
352 2340 : {
353 2340 : SLV2Value value = slv2_plugin_get_uri(plugin);
354 2340 : if (slv2_value_equals(value, plugin_uri_value)) {
355 12 : SLV2Value lib_uri = NULL;
356 12 : TEST_ASSERT(!slv2_value_equals(value, plugin2_uri_value));
357 12 : discovery_plugin_found = 1;
358 12 : lib_uri = slv2_plugin_get_library_uri(plugin);
359 12 : TEST_ASSERT(lib_uri);
360 12 : TEST_ASSERT(slv2_value_is_uri(lib_uri));
361 12 : TEST_ASSERT(slv2_value_as_uri(lib_uri));
362 12 : TEST_ASSERT(strstr(slv2_value_as_uri(lib_uri), "foo.so"));
363 : /* this is already being tested as ticket291, but the discovery and ticket291
364 : * may diverge at some point, so I'm duplicating it here */
365 12 : TEST_ASSERT(slv2_plugin_verify(plugin));
366 : }
367 2340 : }
368 :
369 : int
370 : test_discovery()
371 4 : {
372 : SLV2Plugins plugins;
373 :
374 4 : if (!start_bundle(MANIFEST_PREFIXES
375 : ":plug a lv2:Plugin ; lv2:binary <foo.so> ; rdfs:seeAlso <plugin.ttl> .\n",
376 : BUNDLE_PREFIXES
377 : ":plug a lv2:Plugin ;"
378 : PLUGIN_NAME("Test plugin") " ; "
379 : LICENSE_GPL " ; "
380 : "lv2:port [ a lv2:ControlPort ; a lv2:InputPort ;"
381 : " lv2:index 0 ; lv2:symbol \"foo\" ; lv2:name \"bar\" ; ] ."))
382 0 : return 0;
383 :
384 4 : init_uris();
385 :
386 : /* lookup 1: all plugins (get_all_plugins)
387 : * lookup 2: all plugins (get_plugins_by_filter, always true)
388 : * lookup 3: no plugins (get_plugins_by_filter, always false)
389 : * lookup 4: only example plugin (get_plugins_by_filter)
390 : * lookup 5: no plugins (get_plugins_by_filter, non-existing plugin)
391 : */
392 24 : for (int lookup = 1; lookup <= 5; lookup++) {
393 : //printf("Lookup variant %d\n", lookup);
394 20 : int expect_found = 0;
395 20 : switch (lookup) {
396 : case 1:
397 4 : plugins = slv2_world_get_all_plugins(world);
398 4 : TEST_ASSERT(slv2_plugins_size(plugins) > 0);
399 4 : expect_found = 1;
400 4 : break;
401 : case 2:
402 4 : plugins = slv2_world_get_plugins_by_filter(world,
403 : discovery_plugin_filter_all);
404 4 : TEST_ASSERT(slv2_plugins_size(plugins) > 0);
405 4 : expect_found = 1;
406 4 : break;
407 : case 3:
408 4 : plugins = slv2_world_get_plugins_by_filter(world,
409 : discovery_plugin_filter_none);
410 4 : TEST_ASSERT(slv2_plugins_size(plugins) == 0);
411 4 : break;
412 : case 4:
413 4 : plugins = slv2_world_get_plugins_by_filter(world,
414 : discovery_plugin_filter_ours);
415 4 : TEST_ASSERT(slv2_plugins_size(plugins) == 1);
416 4 : expect_found = 1;
417 4 : break;
418 : case 5:
419 4 : plugins = slv2_world_get_plugins_by_filter(world,
420 : discovery_plugin_filter_fake);
421 4 : TEST_ASSERT(slv2_plugins_size(plugins) == 0);
422 : break;
423 : }
424 :
425 20 : SLV2Plugin explug = slv2_plugins_get_by_uri(plugins, plugin_uri_value);
426 20 : TEST_ASSERT((explug != NULL) == expect_found);
427 20 : SLV2Plugin explug2 = slv2_plugins_get_by_uri(plugins, plugin2_uri_value);
428 20 : TEST_ASSERT(explug2 == NULL);
429 :
430 20 : if (explug && expect_found) {
431 12 : SLV2Value name = slv2_plugin_get_name(explug);
432 12 : TEST_ASSERT(!strcmp(slv2_value_as_string(name), "Test plugin"));
433 12 : slv2_value_free(name);
434 : }
435 :
436 20 : discovery_plugin_found = 0;
437 2360 : for (size_t i = 0; i < slv2_plugins_size(plugins); i++)
438 2340 : discovery_verify_plugin(slv2_plugins_get_at(plugins, i));
439 :
440 20 : TEST_ASSERT(discovery_plugin_found == expect_found);
441 20 : slv2_plugins_free(world, plugins);
442 20 : plugins = NULL;
443 : }
444 :
445 4 : TEST_ASSERT(slv2_plugins_get_at(plugins, (unsigned)INT_MAX + 1) == NULL);
446 :
447 4 : cleanup_uris();
448 :
449 4 : return 1;
450 : }
451 :
452 :
453 : /*****************************************************************************/
454 :
455 : int
456 : test_verify()
457 4 : {
458 4 : if (!start_bundle(MANIFEST_PREFIXES
459 : ":plug a lv2:Plugin ; lv2:binary <foo.so> ; rdfs:seeAlso <plugin.ttl> .\n",
460 : BUNDLE_PREFIXES
461 : ":plug a lv2:Plugin ; "
462 : PLUGIN_NAME("Test plugin") " ; "
463 : LICENSE_GPL " ; "
464 : "lv2:port [ a lv2:ControlPort ; a lv2:InputPort ;"
465 : " lv2:index 0 ; lv2:symbol \"foo\" ; lv2:name \"bar\" ] ."))
466 0 : return 0;
467 :
468 4 : init_uris();
469 4 : SLV2Plugins plugins = slv2_world_get_all_plugins(world);
470 4 : SLV2Plugin explug = slv2_plugins_get_by_uri(plugins, plugin_uri_value);
471 4 : TEST_ASSERT(explug);
472 4 : TEST_ASSERT(slv2_plugin_verify(explug));
473 4 : slv2_plugins_free(world, plugins);
474 4 : cleanup_uris();
475 4 : return 1;
476 : }
477 :
478 : /*****************************************************************************/
479 :
480 : int
481 : test_no_verify()
482 4 : {
483 4 : if (!start_bundle(MANIFEST_PREFIXES
484 : ":plug a lv2:Plugin ; lv2:binary <foo.so> ; rdfs:seeAlso <plugin.ttl> .\n",
485 : BUNDLE_PREFIXES
486 : ":plug a lv2:Plugin . "))
487 0 : return 0;
488 :
489 4 : init_uris();
490 4 : SLV2Plugins plugins = slv2_world_get_all_plugins(world);
491 4 : SLV2Plugin explug = slv2_plugins_get_by_uri(plugins, plugin_uri_value);
492 4 : TEST_ASSERT(explug);
493 4 : TEST_ASSERT(!slv2_plugin_verify(explug));
494 4 : slv2_plugins_free(world, plugins);
495 4 : cleanup_uris();
496 4 : return 1;
497 : }
498 :
499 : /*****************************************************************************/
500 :
501 : int
502 : test_classes()
503 4 : {
504 4 : if (!start_bundle(MANIFEST_PREFIXES
505 : ":plug a lv2:Plugin ; lv2:binary <foo.so> ; rdfs:seeAlso <plugin.ttl> .\n",
506 : BUNDLE_PREFIXES
507 : ":plug a lv2:Plugin ; a lv2:CompressorPlugin ; "
508 : PLUGIN_NAME("Test plugin") " ; "
509 : LICENSE_GPL " ; "
510 : "lv2:port [ "
511 : " a lv2:ControlPort ; a lv2:InputPort ; "
512 : " lv2:index 0 ; lv2:symbol \"foo\" ; lv2:name \"Foo\" ; "
513 : "] ."))
514 0 : return 0;
515 :
516 4 : init_uris();
517 4 : SLV2PluginClass plugin = slv2_world_get_plugin_class(world);
518 4 : SLV2PluginClasses classes = slv2_world_get_plugin_classes(world);
519 4 : SLV2PluginClasses children = slv2_plugin_class_get_children(plugin);
520 :
521 4 : TEST_ASSERT(slv2_plugin_class_get_parent_uri(plugin) == NULL);
522 4 : TEST_ASSERT(slv2_plugin_classes_size(classes) > slv2_plugin_classes_size(children));
523 4 : TEST_ASSERT(!strcmp(slv2_value_as_string(slv2_plugin_class_get_label(plugin)), "Plugin"));
524 4 : TEST_ASSERT(!strcmp(slv2_value_as_string(slv2_plugin_class_get_uri(plugin)),
525 : "http://lv2plug.in/ns/lv2core#Plugin"));
526 :
527 48 : for (unsigned i = 0; i < slv2_plugin_classes_size(children); ++i) {
528 44 : TEST_ASSERT(slv2_value_equals(
529 : slv2_plugin_class_get_parent_uri(slv2_plugin_classes_get_at(children, i)),
530 : slv2_plugin_class_get_uri(plugin)));
531 : }
532 :
533 4 : SLV2Value some_uri = slv2_value_new_uri(world, "http://example.org/whatever");
534 4 : TEST_ASSERT(slv2_plugin_classes_get_by_uri(classes, some_uri) == NULL);
535 4 : slv2_value_free(some_uri);
536 :
537 4 : TEST_ASSERT(slv2_plugin_classes_get_at(classes, (unsigned)INT_MAX + 1) == NULL);
538 :
539 4 : slv2_plugin_classes_free(children);
540 :
541 4 : cleanup_uris();
542 4 : return 1;
543 : }
544 :
545 :
546 : /*****************************************************************************/
547 :
548 : int
549 : test_plugin()
550 8 : {
551 8 : if (!start_bundle(MANIFEST_PREFIXES
552 : ":plug a lv2:Plugin ; lv2:binary <foo.so> ; rdfs:seeAlso <plugin.ttl> .\n",
553 : BUNDLE_PREFIXES
554 : ":plug a lv2:Plugin ; a lv2:CompressorPlugin ; "
555 : PLUGIN_NAME("Test plugin") " ; "
556 : LICENSE_GPL " ; "
557 : "lv2:optionalFeature lv2:hardRtCapable ; "
558 : "lv2:requiredFeature <http://lv2plug.in/ns/ext/event> ; "
559 : ":foo 1.6180 ; "
560 : "doap:maintainer [ foaf:name \"David Robillard\" ; "
561 : " foaf:homepage <http://drobilla.net> ; foaf:mbox <mailto:dave@drobilla.net> ] ; "
562 : "lv2:port [ "
563 : " a lv2:ControlPort ; a lv2:InputPort ; "
564 : " lv2:index 0 ; lv2:symbol \"foo\" ; lv2:name \"bar\" ; "
565 : " lv2:minimum -1.0 ; lv2:maximum 1.0 ; lv2:default 0.5 "
566 : "] , [ "
567 : " a lv2:ControlPort ; a lv2:InputPort ; "
568 : " lv2:index 1 ; lv2:symbol \"bar\" ; lv2:name \"Baz\" ; "
569 : " lv2:minimum -2.0 ; lv2:maximum 2.0 ; lv2:default 1.0 "
570 : "] , [ "
571 : " a lv2:ControlPort ; a lv2:OutputPort ; "
572 : " lv2:index 2 ; lv2:symbol \"latency\" ; lv2:name \"Latency\" ; "
573 : " lv2:portProperty lv2:reportsLatency "
574 : "] . \n"
575 : ":thing doap:name \"Something else\" .\n"))
576 0 : return 0;
577 :
578 8 : init_uris();
579 8 : SLV2Plugins plugins = slv2_world_get_all_plugins(world);
580 8 : SLV2Plugin plug = slv2_plugins_get_by_uri(plugins, plugin_uri_value);
581 8 : TEST_ASSERT(plug);
582 :
583 8 : SLV2PluginClass class = slv2_plugin_get_class(plug);
584 8 : SLV2Value class_uri = slv2_plugin_class_get_uri(class);
585 8 : TEST_ASSERT(!strcmp(slv2_value_as_string(class_uri),
586 : "http://lv2plug.in/ns/lv2core#CompressorPlugin"));
587 :
588 8 : SLV2Value plug_bundle_uri = slv2_plugin_get_bundle_uri(plug);
589 8 : TEST_ASSERT(!strcmp(slv2_value_as_string(plug_bundle_uri), bundle_dir_uri));
590 :
591 8 : SLV2Values data_uris = slv2_plugin_get_data_uris(plug);
592 8 : TEST_ASSERT(slv2_values_size(data_uris) == 2);
593 :
594 8 : char* manifest_uri = (char*)malloc(TEST_PATH_MAX);
595 8 : char* data_uri = (char*)malloc(TEST_PATH_MAX);
596 8 : snprintf(manifest_uri, TEST_PATH_MAX, "%s%s",
597 : slv2_value_as_string(plug_bundle_uri), "manifest.ttl");
598 8 : snprintf(data_uri, TEST_PATH_MAX, "%s%s",
599 : slv2_value_as_string(plug_bundle_uri), "plugin.ttl");
600 :
601 8 : SLV2Value manifest_uri_val = slv2_value_new_uri(world, manifest_uri);
602 8 : TEST_ASSERT(slv2_values_contains(data_uris, manifest_uri_val));
603 8 : slv2_value_free(manifest_uri_val);
604 :
605 8 : TEST_ASSERT(!strcmp(slv2_value_as_string(slv2_values_get_at(data_uris, 0)), manifest_uri));
606 8 : TEST_ASSERT(!strcmp(slv2_value_as_string(slv2_values_get_at(data_uris, 1)), data_uri));
607 :
608 8 : free(manifest_uri);
609 8 : free(data_uri);
610 :
611 : float mins[1];
612 : float maxs[1];
613 : float defs[1];
614 8 : slv2_plugin_get_port_ranges_float(plug, mins, maxs, defs);
615 8 : TEST_ASSERT(mins[0] == -1.0f);
616 8 : TEST_ASSERT(maxs[0] == 1.0f);
617 8 : TEST_ASSERT(defs[0] == 0.5f);
618 :
619 : SLV2Value audio_class = slv2_value_new_uri(world,
620 8 : "http://lv2plug.in/ns/lv2core#AudioPort");
621 : SLV2Value control_class = slv2_value_new_uri(world,
622 8 : "http://lv2plug.in/ns/lv2core#ControlPort");
623 : SLV2Value in_class = slv2_value_new_uri(world,
624 8 : "http://lv2plug.in/ns/lv2core#InputPort");
625 : SLV2Value out_class = slv2_value_new_uri(world,
626 8 : "http://lv2plug.in/ns/lv2core#OutputPort");
627 :
628 8 : TEST_ASSERT(slv2_plugin_get_num_ports_of_class(plug, control_class, NULL) == 3);
629 8 : TEST_ASSERT(slv2_plugin_get_num_ports_of_class(plug, audio_class, NULL) == 0);
630 8 : TEST_ASSERT(slv2_plugin_get_num_ports_of_class(plug, in_class, NULL) == 2);
631 8 : TEST_ASSERT(slv2_plugin_get_num_ports_of_class(plug, out_class, NULL) == 1);
632 8 : TEST_ASSERT(slv2_plugin_get_num_ports_of_class(plug, control_class, in_class, NULL) == 2);
633 8 : TEST_ASSERT(slv2_plugin_get_num_ports_of_class(plug, control_class, out_class, NULL) == 1);
634 8 : TEST_ASSERT(slv2_plugin_get_num_ports_of_class(plug, audio_class, in_class, NULL) == 0);
635 8 : TEST_ASSERT(slv2_plugin_get_num_ports_of_class(plug, audio_class, out_class, NULL) == 0);
636 :
637 8 : TEST_ASSERT(slv2_plugin_has_latency(plug));
638 8 : TEST_ASSERT(slv2_plugin_get_latency_port_index(plug) == 2);
639 :
640 : SLV2Value rt_feature = slv2_value_new_uri(world,
641 8 : "http://lv2plug.in/ns/lv2core#hardRtCapable");
642 : SLV2Value event_feature = slv2_value_new_uri(world,
643 8 : "http://lv2plug.in/ns/ext/event");
644 : SLV2Value pretend_feature = slv2_value_new_uri(world,
645 8 : "http://example.org/solvesWorldHunger");
646 :
647 8 : TEST_ASSERT(slv2_plugin_has_feature(plug, rt_feature));
648 8 : TEST_ASSERT(slv2_plugin_has_feature(plug, event_feature));
649 8 : TEST_ASSERT(!slv2_plugin_has_feature(plug, pretend_feature));
650 :
651 8 : slv2_value_free(rt_feature);
652 8 : slv2_value_free(event_feature);
653 8 : slv2_value_free(pretend_feature);
654 :
655 8 : SLV2Values supported = slv2_plugin_get_supported_features(plug);
656 8 : SLV2Values required = slv2_plugin_get_required_features(plug);
657 8 : SLV2Values optional = slv2_plugin_get_optional_features(plug);
658 8 : TEST_ASSERT(slv2_values_size(supported) == 2);
659 8 : TEST_ASSERT(slv2_values_size(required) == 1);
660 8 : TEST_ASSERT(slv2_values_size(optional) == 1);
661 8 : slv2_values_free(supported);
662 8 : slv2_values_free(required);
663 8 : slv2_values_free(optional);
664 :
665 8 : SLV2Value foo_p = slv2_value_new_uri(world, "http://example.org/foo");
666 8 : SLV2Values foos = slv2_plugin_get_value(plug, foo_p);
667 8 : TEST_ASSERT(slv2_values_size(foos) == 1);
668 8 : TEST_ASSERT(fabs(slv2_value_as_float(slv2_values_get_at(foos, 0)) - 1.6180) < FLT_EPSILON);
669 8 : slv2_value_free(foo_p);
670 8 : slv2_values_free(foos);
671 :
672 8 : SLV2Value author_name = slv2_plugin_get_author_name(plug);
673 8 : TEST_ASSERT(!strcmp(slv2_value_as_string(author_name), "David Robillard"));
674 8 : slv2_value_free(author_name);
675 :
676 8 : SLV2Value author_email = slv2_plugin_get_author_email(plug);
677 8 : TEST_ASSERT(!strcmp(slv2_value_as_string(author_email), "mailto:dave@drobilla.net"));
678 8 : slv2_value_free(author_email);
679 :
680 8 : SLV2Value author_homepage = slv2_plugin_get_author_homepage(plug);
681 8 : TEST_ASSERT(!strcmp(slv2_value_as_string(author_homepage), "http://drobilla.net"));
682 8 : slv2_value_free(author_homepage);
683 :
684 8 : SLV2Value thing_uri = slv2_value_new_uri(world, "http://example.org/thing");
685 8 : SLV2Value name_p = slv2_value_new_uri(world, "http://usefulinc.com/ns/doap#name");
686 8 : SLV2Values thing_names = slv2_plugin_get_value_for_subject(plug, thing_uri, name_p);
687 8 : TEST_ASSERT(slv2_values_size(thing_names) == 1);
688 8 : SLV2Value thing_name = slv2_values_get_at(thing_names, 0);
689 8 : TEST_ASSERT(thing_name);
690 8 : TEST_ASSERT(slv2_value_is_string(thing_name));
691 8 : TEST_ASSERT(!strcmp(slv2_value_as_string(thing_name), "Something else"));
692 :
693 8 : SLV2UIs uis = slv2_plugin_get_uis(plug);
694 8 : TEST_ASSERT(slv2_uis_size(uis) == 0);
695 :
696 : SLV2Results results = slv2_plugin_query_sparql(plug,
697 8 : "SELECT ?name WHERE { <> doap:maintainer [ foaf:name ?name ] }");
698 8 : TEST_ASSERT(!slv2_results_finished(results));
699 8 : TEST_ASSERT(!strcmp(slv2_results_get_binding_name(results, 0), "name"));
700 8 : SLV2Value val = slv2_results_get_binding_value(results, 0);
701 8 : TEST_ASSERT(!strcmp(slv2_value_as_string(val), "David Robillard"));
702 8 : slv2_value_free(val);
703 8 : val = slv2_results_get_binding_value_by_name(results, "name");
704 8 : TEST_ASSERT(!strcmp(slv2_value_as_string(val), "David Robillard"));
705 8 : slv2_value_free(val);
706 :
707 8 : slv2_results_free(results);
708 :
709 8 : slv2_uis_free(uis);
710 8 : slv2_values_free(thing_names);
711 8 : slv2_value_free(thing_uri);
712 8 : slv2_value_free(name_p);
713 8 : slv2_value_free(control_class);
714 8 : slv2_value_free(audio_class);
715 8 : slv2_value_free(in_class);
716 8 : slv2_value_free(out_class);
717 8 : cleanup_uris();
718 8 : return 1;
719 : }
720 :
721 : /*****************************************************************************/
722 :
723 : int
724 : test_port()
725 4 : {
726 4 : if (!start_bundle(MANIFEST_PREFIXES
727 : ":plug a lv2:Plugin ; lv2:binary <foo.so> ; rdfs:seeAlso <plugin.ttl> .\n",
728 : BUNDLE_PREFIXES PREFIX_LV2EV
729 : ":plug a lv2:Plugin ; "
730 : PLUGIN_NAME("Test plugin") " ; "
731 : LICENSE_GPL " ; "
732 : "doap:homepage <http://example.org/someplug> ; "
733 : "lv2:port [ "
734 : " a lv2:ControlPort ; a lv2:InputPort ; "
735 : " lv2:index 0 ; lv2:symbol \"foo\" ; "
736 : " lv2:name \"bar\" ; lv2:name \"le bar\"@fr ; "
737 : " lv2:portProperty lv2:integer ; "
738 : " lv2:minimum -1.0 ; lv2:maximum 1.0 ; lv2:default 0.5 ; "
739 : " lv2:scalePoint [ rdfs:label \"Sin\"; rdf:value 3 ] ; "
740 : " lv2:scalePoint [ rdfs:label \"Cos\"; rdf:value 4 ] "
741 : "] , [\n"
742 : " a lv2:EventPort ; a lv2:InputPort ; "
743 : " lv2:index 1 ; lv2:symbol \"event_in\" ; "
744 : " lv2:name \"Event Input\" ; "
745 : " lv2ev:supportsEvent <http://example.org/event> "
746 : "] ."))
747 0 : return 0;
748 :
749 4 : init_uris();
750 4 : SLV2Plugins plugins = slv2_world_get_all_plugins(world);
751 4 : SLV2Plugin plug = slv2_plugins_get_by_uri(plugins, plugin_uri_value);
752 4 : TEST_ASSERT(plug);
753 :
754 4 : SLV2Value psym = slv2_value_new_string(world, "foo");
755 4 : SLV2Port p = slv2_plugin_get_port_by_index(plug, 0);
756 4 : SLV2Port p2 = slv2_plugin_get_port_by_symbol(plug, psym);
757 4 : slv2_value_free(psym);
758 4 : TEST_ASSERT(p != NULL);
759 4 : TEST_ASSERT(p2 != NULL);
760 4 : TEST_ASSERT(p == p2);
761 :
762 4 : SLV2Value nopsym = slv2_value_new_string(world, "thisaintnoportfoo");
763 4 : SLV2Port p3 = slv2_plugin_get_port_by_symbol(plug, nopsym);
764 4 : TEST_ASSERT(p3 == NULL);
765 4 : slv2_value_free(nopsym);
766 :
767 : SLV2Value audio_class = slv2_value_new_uri(world,
768 4 : "http://lv2plug.in/ns/lv2core#AudioPort");
769 : SLV2Value control_class = slv2_value_new_uri(world,
770 4 : "http://lv2plug.in/ns/lv2core#ControlPort");
771 : SLV2Value in_class = slv2_value_new_uri(world,
772 4 : "http://lv2plug.in/ns/lv2core#InputPort");
773 :
774 4 : TEST_ASSERT(slv2_values_size(slv2_port_get_classes(plug, p)) == 2);
775 4 : TEST_ASSERT(slv2_plugin_get_num_ports(plug) == 2);
776 4 : TEST_ASSERT(slv2_values_get_at(slv2_port_get_classes(plug, p), (unsigned)INT_MAX+1) == NULL);
777 4 : TEST_ASSERT(slv2_port_is_a(plug, p, control_class));
778 4 : TEST_ASSERT(slv2_port_is_a(plug, p, in_class));
779 4 : TEST_ASSERT(!slv2_port_is_a(plug, p, audio_class));
780 :
781 4 : TEST_ASSERT(slv2_values_size(slv2_port_get_properties(plug, p)) == 0);
782 :
783 4 : TEST_ASSERT(!strcmp(slv2_value_as_string(slv2_port_get_symbol(plug, p)), "foo"));
784 4 : SLV2Value name = slv2_port_get_name(plug, p);
785 4 : TEST_ASSERT(!strcmp(slv2_value_as_string(name), "bar"));
786 4 : slv2_value_free(name);
787 :
788 4 : SLV2ScalePoints points = slv2_port_get_scale_points(plug, p);
789 4 : TEST_ASSERT(slv2_scale_points_size(points) == 2);
790 :
791 4 : TEST_ASSERT(slv2_scale_points_get_at(points, (unsigned)INT_MAX+1) == NULL);
792 4 : TEST_ASSERT(slv2_scale_points_get_at(points, 2) == NULL);
793 4 : SLV2ScalePoint sp0 = slv2_scale_points_get_at(points, 0);
794 4 : TEST_ASSERT(sp0);
795 4 : SLV2ScalePoint sp1 = slv2_scale_points_get_at(points, 1);
796 4 : TEST_ASSERT(sp1);
797 :
798 4 : TEST_ASSERT(!strcmp(slv2_value_as_string(slv2_scale_point_get_label(sp0)), "Sin"));
799 4 : TEST_ASSERT(slv2_value_as_float(slv2_scale_point_get_value(sp0)) == 3);
800 4 : TEST_ASSERT(!strcmp(slv2_value_as_string(slv2_scale_point_get_label(sp1)), "Cos"));
801 4 : TEST_ASSERT(slv2_value_as_float(slv2_scale_point_get_value(sp1)) == 4);
802 :
803 4 : SLV2Value homepage_p = slv2_value_new_uri(world, "http://usefulinc.com/ns/doap#homepage");
804 4 : SLV2Values homepages = slv2_plugin_get_value(plug, homepage_p);
805 4 : TEST_ASSERT(slv2_values_size(homepages) == 1);
806 4 : TEST_ASSERT(!strcmp(slv2_value_as_string(slv2_values_get_at(homepages, 0)),
807 : "http://example.org/someplug"));
808 :
809 4 : TEST_ASSERT(slv2_plugin_query_count(plug, "SELECT DISTINCT ?bin WHERE {\n"
810 : "<> lv2:binary ?bin . }") == 1);
811 :
812 4 : TEST_ASSERT(slv2_plugin_query_count(plug, "SELECT DISTINCT ?parent WHERE {\n"
813 : "<> rdfs:subClassOf ?parent . }") == 0);
814 :
815 : SLV2Value min, max, def;
816 4 : slv2_port_get_range(plug, p, &def, &min, &max);
817 4 : TEST_ASSERT(def);
818 4 : TEST_ASSERT(min);
819 4 : TEST_ASSERT(max);
820 4 : TEST_ASSERT(slv2_value_as_float(def) == 0.5);
821 4 : TEST_ASSERT(slv2_value_as_float(min) == -1.0);
822 4 : TEST_ASSERT(slv2_value_as_float(max) == 1.0);
823 :
824 4 : SLV2Value integer_prop = slv2_value_new_uri(world, "http://lv2plug.in/ns/lv2core#integer");
825 4 : SLV2Value toggled_prop = slv2_value_new_uri(world, "http://lv2plug.in/ns/lv2core#toggled");
826 :
827 4 : TEST_ASSERT(slv2_port_has_property(plug, p, integer_prop));
828 4 : TEST_ASSERT(!slv2_port_has_property(plug, p, toggled_prop));
829 :
830 4 : SLV2Port ep = slv2_plugin_get_port_by_index(plug, 1);
831 :
832 4 : SLV2Value event_type = slv2_value_new_uri(world, "http://example.org/event");
833 4 : SLV2Value event_type_2 = slv2_value_new_uri(world, "http://example.org/otherEvent");
834 4 : TEST_ASSERT(slv2_port_supports_event(plug, ep, event_type));
835 4 : TEST_ASSERT(!slv2_port_supports_event(plug, ep, event_type_2));
836 :
837 4 : SLV2Value name_p = slv2_value_new_uri(world, "http://lv2plug.in/ns/lv2core#name");
838 4 : SLV2Values names = slv2_port_get_value(plug, p, name_p);
839 4 : TEST_ASSERT(slv2_values_size(names) == 2);
840 4 : TEST_ASSERT(!strcmp(slv2_value_as_string(slv2_values_get_at(names, 0)),
841 : "bar"));
842 4 : slv2_values_free(names);
843 4 : names = slv2_port_get_value(plug, ep, name_p);
844 4 : TEST_ASSERT(slv2_values_size(names) == 1);
845 4 : TEST_ASSERT(!strcmp(slv2_value_as_string(slv2_values_get_at(names, 0)),
846 : "Event Input"));
847 4 : slv2_values_free(names);
848 4 : slv2_value_free(name_p);
849 :
850 4 : TEST_ASSERT(slv2_port_get_value(plug, p, min) == NULL);
851 :
852 4 : slv2_value_free(integer_prop);
853 4 : slv2_value_free(toggled_prop);
854 4 : slv2_value_free(event_type);
855 4 : slv2_value_free(event_type_2);
856 :
857 4 : slv2_value_free(min);
858 4 : slv2_value_free(max);
859 4 : slv2_value_free(def);
860 :
861 4 : slv2_value_free(homepage_p);
862 4 : slv2_values_free(homepages);
863 :
864 4 : slv2_scale_points_free(points);
865 4 : slv2_value_free(control_class);
866 4 : slv2_value_free(audio_class);
867 4 : slv2_value_free(in_class);
868 4 : slv2_plugins_free(world, plugins);
869 4 : cleanup_uris();
870 4 : return 1;
871 : }
872 :
873 : /*****************************************************************************/
874 :
875 : int
876 : test_ui()
877 4 : {
878 4 : if (!start_bundle(MANIFEST_PREFIXES
879 : ":plug a lv2:Plugin ; lv2:binary <foo.so> ; rdfs:seeAlso <plugin.ttl> .\n",
880 : BUNDLE_PREFIXES PREFIX_LV2UI
881 : ":plug a lv2:Plugin ; a lv2:CompressorPlugin ; "
882 : PLUGIN_NAME("Test plugin") " ; "
883 : LICENSE_GPL " ; "
884 : "lv2:optionalFeature lv2:hardRtCapable ; "
885 : "lv2:requiredFeature <http://lv2plug.in/ns/ext/event> ; "
886 : "lv2ui:ui :ui , :ui2 , :ui3 , :ui4 ; "
887 : "doap:maintainer [ foaf:name \"David Robillard\" ; "
888 : " foaf:homepage <http://drobilla.net> ; foaf:mbox <mailto:dave@drobilla.net> ] ; "
889 : "lv2:port [ "
890 : " a lv2:ControlPort ; a lv2:InputPort ; "
891 : " lv2:index 0 ; lv2:symbol \"foo\" ; lv2:name \"bar\" ; "
892 : " lv2:minimum -1.0 ; lv2:maximum 1.0 ; lv2:default 0.5 "
893 : "] , [ "
894 : " a lv2:ControlPort ; a lv2:InputPort ; "
895 : " lv2:index 1 ; lv2:symbol \"bar\" ; lv2:name \"Baz\" ; "
896 : " lv2:minimum -2.0 ; lv2:maximum 2.0 ; lv2:default 1.0 "
897 : "] , [ "
898 : " a lv2:ControlPort ; a lv2:OutputPort ; "
899 : " lv2:index 2 ; lv2:symbol \"latency\" ; lv2:name \"Latency\" ; "
900 : " lv2:portProperty lv2:reportsLatency "
901 : "] .\n"
902 : ":ui a lv2ui:GtkUI ; "
903 : " lv2ui:requiredFeature lv2ui:makeResident ; "
904 : " lv2ui:binary <ui.so> ; "
905 : " lv2ui:optionalFeature lv2ui:ext_presets . "
906 : ":ui2 a lv2ui:GtkUI ; lv2ui:binary <ui2.so> . "
907 : ":ui3 a lv2ui:GtkUI ; lv2ui:binary <ui3.so> . "
908 : ":ui4 a lv2ui:GtkUI ; lv2ui:binary <ui4.so> . "))
909 0 : return 0;
910 :
911 4 : init_uris();
912 4 : SLV2Plugins plugins = slv2_world_get_all_plugins(world);
913 4 : SLV2Plugin plug = slv2_plugins_get_by_uri(plugins, plugin_uri_value);
914 4 : TEST_ASSERT(plug);
915 :
916 4 : SLV2UIs uis = slv2_plugin_get_uis(plug);
917 4 : TEST_ASSERT(slv2_uis_size(uis) == 4);
918 :
919 4 : TEST_ASSERT(slv2_uis_get_at(uis, (unsigned)INT_MAX + 1) == NULL);
920 :
921 4 : SLV2UI ui0 = slv2_uis_get_at(uis, 0);
922 4 : TEST_ASSERT(ui0);
923 :
924 4 : SLV2Value ui_uri = slv2_value_new_uri(world, "http://example.org/ui");
925 4 : SLV2Value ui2_uri = slv2_value_new_uri(world, "http://example.org/ui3");
926 4 : SLV2Value ui3_uri = slv2_value_new_uri(world, "http://example.org/ui4");
927 4 : SLV2Value noui_uri = slv2_value_new_uri(world, "http://example.org/notaui");
928 :
929 4 : SLV2UI ui0_2 = slv2_uis_get_by_uri(uis, ui_uri);
930 4 : TEST_ASSERT(ui0 == ui0_2);
931 :
932 4 : SLV2UI ui2 = slv2_uis_get_by_uri(uis, ui2_uri);
933 4 : TEST_ASSERT(ui2 != ui0);
934 :
935 4 : SLV2UI ui3 = slv2_uis_get_by_uri(uis, ui3_uri);
936 4 : TEST_ASSERT(ui3 != ui0);
937 :
938 4 : SLV2UI noui = slv2_uis_get_by_uri(uis, noui_uri);
939 4 : TEST_ASSERT(noui == NULL);
940 :
941 4 : SLV2Values classes = slv2_ui_get_classes(ui0);
942 4 : TEST_ASSERT(slv2_values_size(classes) == 1);
943 :
944 : SLV2Value ui_class_uri = slv2_value_new_uri(world,
945 4 : "http://lv2plug.in/ns/extensions/ui#GtkUI");
946 :
947 4 : TEST_ASSERT(slv2_value_equals(slv2_values_get_at(classes, 0), ui_class_uri));
948 4 : TEST_ASSERT(slv2_ui_is_a(ui0, ui_class_uri));
949 :
950 4 : SLV2Value plug_bundle_uri = slv2_plugin_get_bundle_uri(plug);
951 4 : SLV2Value ui_bundle_uri = slv2_ui_get_bundle_uri(ui0);
952 4 : TEST_ASSERT(slv2_value_equals(plug_bundle_uri, ui_bundle_uri));
953 :
954 4 : char* ui_binary_uri_str = (char*)malloc(TEST_PATH_MAX);
955 4 : snprintf(ui_binary_uri_str, TEST_PATH_MAX, "%s%s",
956 : slv2_value_as_string(plug_bundle_uri), "ui.so");
957 :
958 4 : SLV2Value ui_binary_uri = slv2_ui_get_binary_uri(ui0);
959 :
960 4 : SLV2Value expected_uri = slv2_value_new_uri(world, ui_binary_uri_str);
961 4 : TEST_ASSERT(slv2_value_equals(expected_uri, ui_binary_uri));
962 :
963 4 : free(ui_binary_uri_str);
964 4 : slv2_value_free(ui_class_uri);
965 4 : slv2_value_free(ui_uri);
966 4 : slv2_value_free(ui2_uri);
967 4 : slv2_value_free(ui3_uri);
968 4 : slv2_value_free(noui_uri);
969 4 : slv2_value_free(expected_uri);
970 4 : slv2_uis_free(uis);
971 :
972 4 : cleanup_uris();
973 4 : return 1;
974 : }
975 :
976 : /*****************************************************************************/
977 :
978 : /* add tests here */
979 : static struct TestCase tests[] = {
980 : TEST_CASE(utils),
981 : TEST_CASE(value),
982 : TEST_CASE(values),
983 : TEST_CASE(verify),
984 : TEST_CASE(no_verify),
985 : TEST_CASE(discovery),
986 : TEST_CASE(classes),
987 : TEST_CASE(plugin),
988 : TEST_CASE(port),
989 : TEST_CASE(plugin),
990 : TEST_CASE(ui),
991 : { NULL, NULL }
992 : };
993 :
994 : void
995 : run_tests()
996 4 : {
997 : int i;
998 48 : for (i = 0; tests[i].title; i++) {
999 44 : printf("--- Test: %s\n", tests[i].title);
1000 44 : if (!tests[i].func()) {
1001 0 : printf("\nTest failed\n");
1002 : /* test case that wasn't able to be executed at all counts as 1 test + 1 error */
1003 0 : error_count++;
1004 0 : test_count++;
1005 : }
1006 44 : unload_bundle();
1007 44 : cleanup();
1008 : }
1009 4 : }
1010 :
1011 : int
1012 : main(int argc, char *argv[])
1013 4 : {
1014 4 : if (argc != 1) {
1015 0 : printf("Syntax: %s\n", argv[0]);
1016 0 : return 0;
1017 : }
1018 4 : init_tests();
1019 4 : run_tests();
1020 4 : cleanup();
1021 4 : printf("\n***\n*** Test Results: %d tests, %d errors\n***\n\n", test_count, error_count);
1022 4 : return error_count ? 1 : 0;
1023 : }
1024 :
|
