falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10 Commits
16 Branches
14GB
Tree: 366f1f1680
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '366f1f1680'
${ noResults }
Carla/source/libs/lilv/lilv-0.14.4/test/lilv_test.c

1582 lines
51KB
Raw Blame History 

  1. /*

  2.   Copyright 2007-2011 David Robillard <http://drobilla.net>

  3.   Copyright 2008 Krzysztof Foltman

  4. 

  5.   Permission to use, copy, modify, and/or distribute this software for any

  6.   purpose with or without fee is hereby granted, provided that the above

  7.   copyright notice and this permission notice appear in all copies.

  8. 

  9.   THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

  10.   WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

  11.   MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

  12.   ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

  13.   WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

  14.   ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

  15.   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

  16. */

  17. 

  18. #define _POSIX_C_SOURCE 200112L /* for setenv */

  19. 

  20. #include <assert.h>

  21. #include <ctype.h>

  22. #include <errno.h>

  23. #include <float.h>

  24. #include <limits.h>

  25. #include <math.h>

  26. #include <stdio.h>

  27. #include <stdlib.h>

  28. #include <string.h>

  29. #include <sys/stat.h>

  30. 

  31. #ifdef _WIN32

  32. #    include <direct.h>

  33. #    define mkdir(path, flags) _mkdir(path)

  34. #    define setenv(n, v, r) SetEnvironmentVariable((n), (v))

  35. #    define unsetenv(n) SetEnvironmentVariable((n), NULL)

  36. #else

  37. #    include <dirent.h>

  38. #    include <unistd.h>

  39. #endif

  40. 

  41. #include "lilv/lilv.h"

  42. #include "../src/lilv_internal.h"

  43. 

  44. #include "lv2/lv2plug.in/ns/ext/state/state.h"

  45. #include "lv2/lv2plug.in/ns/ext/urid/urid.h"

  46. 

  47. #define TEST_PATH_MAX 1024

  48. 

  49. #if defined(__APPLE__)

  50. #    define SHLIB_EXT ".dylib"

  51. #elif defined(_WIN32)

  52. #    define SHLIB_EXT ".dll"

  53. #else

  54. #    define SHLIB_EXT ".so"

  55. #endif

  56. 

  57. static char bundle_dir_name[TEST_PATH_MAX];

  58. static char bundle_dir_uri[TEST_PATH_MAX];

  59. static char manifest_name[TEST_PATH_MAX];

  60. static char content_name[TEST_PATH_MAX];

  61. 

  62. static LilvWorld* world;

  63. 

  64. int test_count  = 0;

  65. int error_count = 0;

  66. 

  67. static void

  68. delete_bundle(void)

  69. {

  70. 	unlink(content_name);

  71. 	unlink(manifest_name);

  72. 	remove(bundle_dir_name);

  73. }

  74. 

  75. static void

  76. init_tests(void)

  77. {

  78. 	strncpy(bundle_dir_name, getenv("HOME"), 900);

  79. 	strcat(bundle_dir_name, "/.lv2");

  80. 	mkdir(bundle_dir_name, 0700);

  81. 	strcat(bundle_dir_name, "/lilv-test.lv2");

  82. 	sprintf(bundle_dir_uri, "file://%s/", bundle_dir_name);

  83. 	sprintf(manifest_name, "%s/manifest.ttl", bundle_dir_name);

  84. 	sprintf(content_name, "%s/plugin.ttl", bundle_dir_name);

  85. 

  86. 	delete_bundle();

  87. }

  88. 

  89. static void

  90. fatal_error(const char* err, const char* arg)

  91. {

  92. 	/* TODO: possibly change to vfprintf later */

  93. 	fprintf(stderr, err, arg);

  94. 	/* IMHO, the bundle should be left in place after an error, for possible investigation */

  95. 	/* delete_bundle(); */

  96. 	exit(1);

  97. }

  98. 

  99. static void

  100. write_file(const char* name, const char* content)

  101. {

  102. 	FILE* f = fopen(name, "w");

  103. 	size_t len = strlen(content);

  104. 	if (fwrite(content, 1, len, f) != len)

  105. 		fatal_error("Cannot write file %s\n", name);

  106. 	fclose(f);

  107. }

  108. 

  109. static int

  110. init_world(void)

  111. {

  112. 	world = lilv_world_new();

  113. 	return world != NULL;

  114. }

  115. 

  116. static int

  117. load_all_bundles(void)

  118. {

  119. 	if (!init_world())

  120. 		return 0;

  121. 	lilv_world_load_all(world);

  122. 	return 1;

  123. }

  124. 

  125. static void

  126. create_bundle(const char* manifest, const char* content)

  127. {

  128. 	if (mkdir(bundle_dir_name, 0700) && errno != EEXIST)

  129. 		fatal_error("Cannot create directory %s\n", bundle_dir_name);

  130. 	write_file(manifest_name, manifest);

  131. 	write_file(content_name, content);

  132. }

  133. 

  134. static int

  135. start_bundle(const char* manifest, const char* content)

  136. {

  137. 	create_bundle(manifest, content);

  138. 	return load_all_bundles();

  139. }

  140. 

  141. static void

  142. unload_bundle(void)

  143. {

  144. 	if (world)

  145. 		lilv_world_free(world);

  146. 	world = NULL;

  147. }

  148. 

  149. static void

  150. cleanup(void)

  151. {

  152. 	delete_bundle();

  153. }

  154. 

  155. /*****************************************************************************/

  156. 

  157. #define TEST_CASE(name) { #name, test_##name }

  158. #define TEST_ASSERT(check) do {\

  159. 	test_count++;\

  160. 	if (!(check)) {\

  161. 		error_count++;\

  162. 		fprintf(stderr, "lilv_test.c:%d: error: %s\n", __LINE__, #check);\

  163. 	}\

  164. } while (0)

  165. 

  166. typedef int (*TestFunc)(void);

  167. 

  168. struct TestCase {

  169. 	const char* title;

  170. 	TestFunc func;

  171. };

  172. 

  173. #define PREFIX_LINE "@prefix : <http://example.org/> .\n"

  174. #define PREFIX_LV2 "@prefix lv2: <http://lv2plug.in/ns/lv2core#> .\n"

  175. #define PREFIX_LV2EV "@prefix lv2ev: <http://lv2plug.in/ns/ext/event#> . \n"

  176. #define PREFIX_LV2UI "@prefix lv2ui: <http://lv2plug.in/ns/extensions/ui#> .\n"

  177. #define PREFIX_RDF "@prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .\n"

  178. #define PREFIX_RDFS "@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .\n"

  179. #define PREFIX_FOAF "@prefix foaf: <http://xmlns.com/foaf/0.1/> .\n"

  180. #define PREFIX_DOAP "@prefix doap: <http://usefulinc.com/ns/doap#> .\n"

  181. 

  182. #define MANIFEST_PREFIXES PREFIX_LINE PREFIX_LV2 PREFIX_RDFS

  183. #define BUNDLE_PREFIXES PREFIX_LINE PREFIX_LV2 PREFIX_RDF PREFIX_RDFS PREFIX_FOAF PREFIX_DOAP

  184. #define PLUGIN_NAME(name) "doap:name \"" name "\""

  185. #define LICENSE_GPL "doap:license <http://usefulinc.com/doap/licenses/gpl>"

  186. 

  187. static const char* uris_plugin = "http://example.org/plug";

  188. static LilvNode* plugin_uri_value;

  189. static LilvNode* plugin2_uri_value;

  190. 

  191. /*****************************************************************************/

  192. 

  193. static void

  194. init_uris(void)

  195. {

  196. 	plugin_uri_value = lilv_new_uri(world, uris_plugin);

  197. 	plugin2_uri_value = lilv_new_uri(world, "http://example.org/foobar");

  198. 	TEST_ASSERT(plugin_uri_value);

  199. 	TEST_ASSERT(plugin2_uri_value);

  200. }

  201. 

  202. static void

  203. cleanup_uris(void)

  204. {

  205. 	lilv_node_free(plugin2_uri_value);

  206. 	lilv_node_free(plugin_uri_value);

  207. 	plugin2_uri_value = NULL;

  208. 	plugin_uri_value = NULL;

  209. }

  210. 

  211. /*****************************************************************************/

  212. 

  213. static int

  214. test_utils(void)

  215. {

  216. 	TEST_ASSERT(!strcmp(lilv_uri_to_path("file:///tmp/blah"), "/tmp/blah"));

  217. 	TEST_ASSERT(!lilv_uri_to_path("file:/example.org/blah"));

  218. 	TEST_ASSERT(!lilv_uri_to_path("http://example.org/blah"));

  219. 	return 1;

  220. }

  221. 

  222. /*****************************************************************************/

  223. 

  224. static int

  225. test_value(void)

  226. {

  227. 	if (!start_bundle(MANIFEST_PREFIXES

  228. 			":plug a lv2:Plugin ; lv2:binary <foo" SHLIB_EXT "> ; rdfs:seeAlso <plugin.ttl> .\n",

  229. 			BUNDLE_PREFIXES

  230. 			":plug a lv2:Plugin ; a lv2:CompressorPlugin ; "

  231. 			PLUGIN_NAME("Test plugin") " ; "

  232. 			LICENSE_GPL " ; "

  233. 			"lv2:port [ "

  234. 			"  a lv2:ControlPort ; a lv2:InputPort ; "

  235. 			"  lv2:index 0 ; lv2:symbol \"foo\" ; lv2:name \"Foo\" ; "

  236. 			"] ."))

  237. 		return 0;

  238. 

  239. 	init_uris();

  240. 

  241. 	LilvNode* uval = lilv_new_uri(world, "http://example.org");

  242. 	LilvNode* sval = lilv_new_string(world, "Foo");

  243. 	LilvNode* ival = lilv_new_int(world, 42);

  244. 	LilvNode* fval = lilv_new_float(world, 1.6180);

  245. 

  246. 	TEST_ASSERT(lilv_node_is_uri(uval));

  247. 	TEST_ASSERT(lilv_node_is_string(sval));

  248. 	TEST_ASSERT(lilv_node_is_int(ival));

  249. 	TEST_ASSERT(lilv_node_is_float(fval));

  250. 

  251. 	TEST_ASSERT(!lilv_node_is_literal(uval));

  252. 	TEST_ASSERT(lilv_node_is_literal(sval));

  253. 	TEST_ASSERT(lilv_node_is_literal(ival));

  254. 	TEST_ASSERT(lilv_node_is_literal(fval));

  255. 

  256. 	TEST_ASSERT(!strcmp(lilv_node_as_uri(uval), "http://example.org"));

  257. 	TEST_ASSERT(!strcmp(lilv_node_as_string(sval), "Foo"));

  258. 	TEST_ASSERT(lilv_node_as_int(ival) == 42);

  259. 	TEST_ASSERT(fabs(lilv_node_as_float(fval) - 1.6180) < FLT_EPSILON);

  260. 

  261. 	char* tok = lilv_node_get_turtle_token(uval);

  262. 	TEST_ASSERT(!strcmp(tok, "<http://example.org>"));

  263. 	free(tok);

  264. 	tok = lilv_node_get_turtle_token(sval);

  265. 	TEST_ASSERT(!strcmp(tok, "Foo"));

  266. 	free(tok);

  267. 	tok = lilv_node_get_turtle_token(ival);

  268. 	TEST_ASSERT(!strcmp(tok, "42"));

  269. 	free(tok);

  270. 	tok = lilv_node_get_turtle_token(fval);

  271. 	TEST_ASSERT(!strncmp(tok, "1.6180", 6));

  272. 	free(tok);

  273. 

  274. 	LilvNode* uval_e = lilv_new_uri(world, "http://example.org");

  275. 	LilvNode* sval_e = lilv_new_string(world, "Foo");

  276. 	LilvNode* ival_e = lilv_new_int(world, 42);

  277. 	LilvNode* fval_e = lilv_new_float(world, 1.6180);

  278. 	LilvNode* uval_ne = lilv_new_uri(world, "http://no-example.org");

  279. 	LilvNode* sval_ne = lilv_new_string(world, "Bar");

  280. 	LilvNode* ival_ne = lilv_new_int(world, 24);

  281. 	LilvNode* fval_ne = lilv_new_float(world, 3.14159);

  282. 

  283. 	TEST_ASSERT(lilv_node_equals(uval, uval_e));

  284. 	TEST_ASSERT(lilv_node_equals(sval, sval_e));

  285. 	TEST_ASSERT(lilv_node_equals(ival, ival_e));

  286. 	TEST_ASSERT(lilv_node_equals(fval, fval_e));

  287. 

  288. 	TEST_ASSERT(!lilv_node_equals(uval, uval_ne));

  289. 	TEST_ASSERT(!lilv_node_equals(sval, sval_ne));

  290. 	TEST_ASSERT(!lilv_node_equals(ival, ival_ne));

  291. 	TEST_ASSERT(!lilv_node_equals(fval, fval_ne));

  292. 

  293. 	TEST_ASSERT(!lilv_node_equals(uval, sval));

  294. 	TEST_ASSERT(!lilv_node_equals(sval, ival));

  295. 	TEST_ASSERT(!lilv_node_equals(ival, fval));

  296. 

  297. 	LilvNode* uval_dup = lilv_node_duplicate(uval);

  298. 	TEST_ASSERT(lilv_node_equals(uval, uval_dup));

  299. 

  300. 	LilvNode* ifval = lilv_new_float(world, 42.0);

  301. 	TEST_ASSERT(!lilv_node_equals(ival, ifval));

  302. 	lilv_node_free(ifval);

  303. 

  304. 	LilvNode* nil = NULL;

  305. 	TEST_ASSERT(!lilv_node_equals(uval, nil));

  306. 	TEST_ASSERT(!lilv_node_equals(nil, uval));

  307. 	TEST_ASSERT(lilv_node_equals(nil, nil));

  308. 

  309. 	LilvNode* nil2 = lilv_node_duplicate(nil);

  310. 	TEST_ASSERT(lilv_node_equals(nil, nil2));

  311. 

  312. 	lilv_node_free(uval);

  313. 	lilv_node_free(sval);

  314. 	lilv_node_free(ival);

  315. 	lilv_node_free(fval);

  316. 	lilv_node_free(uval_e);

  317. 	lilv_node_free(sval_e);

  318. 	lilv_node_free(ival_e);

  319. 	lilv_node_free(fval_e);

  320. 	lilv_node_free(uval_ne);

  321. 	lilv_node_free(sval_ne);

  322. 	lilv_node_free(ival_ne);

  323. 	lilv_node_free(fval_ne);

  324. 	lilv_node_free(uval_dup);

  325. 	lilv_node_free(nil2);

  326. 

  327. 	cleanup_uris();

  328. 	return 1;

  329. }

  330. 

  331. /*****************************************************************************/

  332. 

  333. static int discovery_plugin_found = 0;

  334. 

  335. static void

  336. discovery_verify_plugin(const LilvPlugin* plugin)

  337. {

  338. 	const LilvNode* value = lilv_plugin_get_uri(plugin);

  339. 	if (lilv_node_equals(value, plugin_uri_value)) {

  340. 		const LilvNode* lib_uri = NULL;

  341. 		TEST_ASSERT(!lilv_node_equals(value, plugin2_uri_value));

  342. 		discovery_plugin_found = 1;

  343. 		lib_uri = lilv_plugin_get_library_uri(plugin);

  344. 		TEST_ASSERT(lib_uri);

  345. 		TEST_ASSERT(lilv_node_is_uri(lib_uri));

  346. 		TEST_ASSERT(lilv_node_as_uri(lib_uri));

  347. 		TEST_ASSERT(strstr(lilv_node_as_uri(lib_uri), "foo" SHLIB_EXT));

  348. 		TEST_ASSERT(lilv_plugin_verify(plugin));

  349. 	}

  350. }

  351. 

  352. static int

  353. test_discovery(void)

  354. {

  355. 	if (!start_bundle(MANIFEST_PREFIXES

  356. 			":plug a lv2:Plugin ; lv2:binary <foo" SHLIB_EXT "> ; rdfs:seeAlso <plugin.ttl> .\n",

  357. 			BUNDLE_PREFIXES

  358. 			":plug a lv2:Plugin ;"

  359. 			PLUGIN_NAME("Test plugin") " ; "

  360. 			LICENSE_GPL " ; "

  361. 			"lv2:port [ a lv2:ControlPort ; a lv2:InputPort ;"

  362. 			" lv2:index 0 ; lv2:symbol \"foo\" ; lv2:name \"bar\" ; ] ."))

  363. 		return 0;

  364. 

  365. 	init_uris();

  366. 

  367. 	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);

  368. 	TEST_ASSERT(lilv_plugins_size(plugins) > 0);

  369. 

  370. 	const LilvPlugin* explug = lilv_plugins_get_by_uri(plugins, plugin_uri_value);

  371. 	TEST_ASSERT(explug != NULL);

  372. 	const LilvPlugin* explug2 = lilv_plugins_get_by_uri(plugins, plugin2_uri_value);

  373. 	TEST_ASSERT(explug2 == NULL);

  374. 

  375. 	if (explug) {

  376. 		LilvNode* name = lilv_plugin_get_name(explug);

  377. 		TEST_ASSERT(!strcmp(lilv_node_as_string(name), "Test plugin"));

  378. 		lilv_node_free(name);

  379. 	}

  380. 

  381. 	discovery_plugin_found = 0;

  382. 	LILV_FOREACH(plugins, i, plugins)

  383. 		discovery_verify_plugin(lilv_plugins_get(plugins, i));

  384. 

  385. 	TEST_ASSERT(discovery_plugin_found);

  386. 	plugins = NULL;

  387. 

  388. 	cleanup_uris();

  389. 

  390. 	return 1;

  391. }

  392. 

  393. /*****************************************************************************/

  394. 

  395. static int

  396. test_lv2_path(void)

  397. {

  398. #ifndef _WIN32

  399. 	char* orig_lv2_path = lilv_strdup(getenv("LV2_PATH"));

  400. 

  401. 	setenv("LV2_PATH", "~/.lv2:/usr/local/lib/lv2:/usr/lib/lv2", 1);

  402. 

  403. 	world = lilv_world_new();

  404. 	lilv_world_load_all(world);

  405. 

  406. 	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);

  407. 	const size_t n_plugins     = lilv_plugins_size(plugins);

  408. 

  409. 	lilv_world_free(world);

  410. 

  411. 	setenv("LV2_PATH", "$HOME/.lv2:/usr/local/lib/lv2:/usr/lib/lv2", 1);

  412. 	world = lilv_world_new();

  413. 	lilv_world_load_all(world);

  414. 	plugins = lilv_world_get_all_plugins(world);

  415. 	TEST_ASSERT(lilv_plugins_size(plugins) == n_plugins);

  416. 	lilv_world_free(world);

  417. 	world = NULL;

  418. 

  419. 	if (orig_lv2_path) {

  420. 		setenv("LV2_PATH", orig_lv2_path, 1);

  421. 	} else {

  422. 		unsetenv("LV2_PATH");

  423. 	}

  424. 	free(orig_lv2_path);

  425. #endif

  426. 	return 1;

  427. }

  428. 

  429. /*****************************************************************************/

  430. 

  431. static int

  432. test_verify(void)

  433. {

  434. 	if (!start_bundle(MANIFEST_PREFIXES

  435. 			":plug a lv2:Plugin ; lv2:binary <foo" SHLIB_EXT "> ; rdfs:seeAlso <plugin.ttl> .\n",

  436. 			BUNDLE_PREFIXES

  437. 			":plug a lv2:Plugin ; "

  438. 			PLUGIN_NAME("Test plugin") " ; "

  439. 			LICENSE_GPL " ; "

  440. 			"lv2:port [ a lv2:ControlPort ; a lv2:InputPort ;"

  441. 			" lv2:index 0 ; lv2:symbol \"foo\" ; lv2:name \"bar\" ] ."))

  442. 		return 0;

  443. 

  444. 	init_uris();

  445. 	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);

  446. 	const LilvPlugin* explug = lilv_plugins_get_by_uri(plugins, plugin_uri_value);

  447. 	TEST_ASSERT(explug);

  448. 	TEST_ASSERT(lilv_plugin_verify(explug));

  449. 	cleanup_uris();

  450. 	return 1;

  451. }

  452. 

  453. /*****************************************************************************/

  454. 

  455. static int

  456. test_no_verify(void)

  457. {

  458. 	if (!start_bundle(MANIFEST_PREFIXES

  459. 			":plug a lv2:Plugin ; lv2:binary <foo" SHLIB_EXT "> ; rdfs:seeAlso <plugin.ttl> .\n",

  460. 			BUNDLE_PREFIXES

  461. 			":plug a lv2:Plugin . "))

  462. 		return 0;

  463. 

  464. 	init_uris();

  465. 	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);

  466. 	const LilvPlugin* explug = lilv_plugins_get_by_uri(plugins, plugin_uri_value);

  467. 	TEST_ASSERT(explug);

  468. 	TEST_ASSERT(!lilv_plugin_verify(explug));

  469. 	cleanup_uris();

  470. 	return 1;

  471. }

  472. 

  473. /*****************************************************************************/

  474. 

  475. static int

  476. test_classes(void)

  477. {

  478. 	if (!start_bundle(MANIFEST_PREFIXES

  479. 			":plug a lv2:Plugin ; lv2:binary <foo" SHLIB_EXT "> ; rdfs:seeAlso <plugin.ttl> .\n",

  480. 			BUNDLE_PREFIXES

  481. 			":plug a lv2:Plugin ; a lv2:CompressorPlugin ; "

  482. 			PLUGIN_NAME("Test plugin") " ; "

  483. 			LICENSE_GPL " ; "

  484. 			"lv2:port [ "

  485. 			"  a lv2:ControlPort ; a lv2:InputPort ; "

  486. 			"  lv2:index 0 ; lv2:symbol \"foo\" ; lv2:name \"Foo\" ; "

  487. 			"] ."))

  488. 		return 0;

  489. 

  490. 	init_uris();

  491. 	const LilvPluginClass*   plugin   = lilv_world_get_plugin_class(world);

  492. 	const LilvPluginClasses* classes  = lilv_world_get_plugin_classes(world);

  493. 	LilvPluginClasses*       children = lilv_plugin_class_get_children(plugin);

  494. 

  495. 	TEST_ASSERT(lilv_plugin_class_get_parent_uri(plugin) == NULL);

  496. 	TEST_ASSERT(lilv_plugin_classes_size(classes) > lilv_plugin_classes_size(children));

  497. 	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_plugin_class_get_label(plugin)), "Plugin"));

  498. 	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_plugin_class_get_uri(plugin)),

  499. 	                    "http://lv2plug.in/ns/lv2core#Plugin"));

  500. 

  501. 	LILV_FOREACH(plugin_classes, i, children) {

  502. 		TEST_ASSERT(lilv_node_equals(

  503. 				lilv_plugin_class_get_parent_uri(lilv_plugin_classes_get(children, i)),

  504. 				lilv_plugin_class_get_uri(plugin)));

  505. 	}

  506. 

  507. 	LilvNode* some_uri = lilv_new_uri(world, "http://example.org/whatever");

  508. 	TEST_ASSERT(lilv_plugin_classes_get_by_uri(classes, some_uri) == NULL);

  509. 	lilv_node_free(some_uri);

  510. 

  511. 	lilv_plugin_classes_free(children);

  512. 

  513. 	cleanup_uris();

  514. 	return 1;

  515. }

  516. 

  517. /*****************************************************************************/

  518. 

  519. static int

  520. test_plugin(void)

  521. {

  522. 	if (!start_bundle(MANIFEST_PREFIXES

  523. 			":plug a lv2:Plugin ; lv2:binary <foo" SHLIB_EXT "> ; rdfs:seeAlso <plugin.ttl> .\n",

  524. 			BUNDLE_PREFIXES

  525. 			":plug a lv2:Plugin ; a lv2:CompressorPlugin ; "

  526. 			PLUGIN_NAME("Test plugin") " ; "

  527. 			LICENSE_GPL " ; "

  528. 			"lv2:optionalFeature lv2:hardRTCapable ; "

  529. 			"lv2:requiredFeature <http://lv2plug.in/ns/ext/event> ; "

  530. 			"lv2:extensionData <http://example.org/extdata> ;"

  531. 			":foo 1.6180 ; "

  532. 			":bar true ; "

  533. 			":baz false ; "

  534. 			":blank [ a <http://example.org/blank> ] ; "

  535. 			"doap:maintainer [ foaf:name \"David Robillard\" ; "

  536. 			"  foaf:homepage <http://drobilla.net> ; foaf:mbox <mailto:d@drobilla.net> ] ; "

  537. 			"lv2:port [ "

  538. 			"  a lv2:ControlPort ; a lv2:InputPort ; "

  539. 			"  lv2:index 0 ; lv2:symbol \"foo\" ; lv2:name \"bar\" ; "

  540. 			"  lv2:minimum -1.0 ; lv2:maximum 1.0 ; lv2:default 0.5 "

  541. 			"] , [ "

  542. 			"  a lv2:ControlPort ; a lv2:InputPort ; "

  543. 			"  lv2:index 1 ; lv2:symbol \"bar\" ; lv2:name \"Baz\" ; "

  544. 			"  lv2:minimum -2.0 ; lv2:maximum 2.0 ; lv2:default 1.0 "

  545. 			"] , [ "

  546. 			"  a lv2:ControlPort ; a lv2:OutputPort ; "

  547. 			"  lv2:index 2 ; lv2:symbol \"latency\" ; lv2:name \"Latency\" ; "

  548. 			"  lv2:portProperty lv2:reportsLatency ; "

  549. 			"  lv2:designation lv2:latency "

  550. 			"] . \n"

  551. 			":thing doap:name \"Something else\" .\n"))

  552. 		return 0;

  553. 

  554. 	init_uris();

  555. 	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);

  556. 	const LilvPlugin* plug = lilv_plugins_get_by_uri(plugins, plugin_uri_value);

  557. 	TEST_ASSERT(plug);

  558. 

  559. 	const LilvPluginClass* klass = lilv_plugin_get_class(plug);

  560. 	const LilvNode* klass_uri = lilv_plugin_class_get_uri(klass);

  561. 	TEST_ASSERT(!strcmp(lilv_node_as_string(klass_uri),

  562. 			"http://lv2plug.in/ns/lv2core#CompressorPlugin"));

  563. 

  564. 	const LilvNode* plug_bundle_uri = lilv_plugin_get_bundle_uri(plug);

  565. 	TEST_ASSERT(!strcmp(lilv_node_as_string(plug_bundle_uri), bundle_dir_uri));

  566. 

  567. 	const LilvNodes* data_uris = lilv_plugin_get_data_uris(plug);

  568. 	TEST_ASSERT(lilv_nodes_size(data_uris) == 2);

  569. 

  570. 	char* manifest_uri = (char*)malloc(TEST_PATH_MAX);

  571. 	char* data_uri     = (char*)malloc(TEST_PATH_MAX);

  572. 	snprintf(manifest_uri, TEST_PATH_MAX, "%s%s",

  573. 			lilv_node_as_string(plug_bundle_uri), "manifest.ttl");

  574. 	snprintf(data_uri, TEST_PATH_MAX, "%s%s",

  575. 			lilv_node_as_string(plug_bundle_uri), "plugin.ttl");

  576. 

  577. 	LilvNode* manifest_uri_val = lilv_new_uri(world, manifest_uri);

  578. 	TEST_ASSERT(lilv_nodes_contains(data_uris, manifest_uri_val));

  579. 	lilv_node_free(manifest_uri_val);

  580. 

  581. 	LilvNode* data_uri_val = lilv_new_uri(world, data_uri);

  582. 	TEST_ASSERT(lilv_nodes_contains(data_uris, data_uri_val));

  583. 	lilv_node_free(data_uri_val);

  584. 

  585. 	free(manifest_uri);

  586. 	free(data_uri);

  587. 

  588. 	float mins[3];

  589. 	float maxs[3];

  590. 	float defs[3];

  591. 	lilv_plugin_get_port_ranges_float(plug, mins, maxs, defs);

  592. 	TEST_ASSERT(mins[0] == -1.0f);

  593. 	TEST_ASSERT(maxs[0] == 1.0f);

  594. 	TEST_ASSERT(defs[0] == 0.5f);

  595. 

  596. 	LilvNode* audio_class = lilv_new_uri(world,

  597. 			"http://lv2plug.in/ns/lv2core#AudioPort");

  598. 	LilvNode* control_class = lilv_new_uri(world,

  599. 			"http://lv2plug.in/ns/lv2core#ControlPort");

  600. 	LilvNode* in_class = lilv_new_uri(world,

  601. 			"http://lv2plug.in/ns/lv2core#InputPort");

  602. 	LilvNode* out_class = lilv_new_uri(world,

  603. 			"http://lv2plug.in/ns/lv2core#OutputPort");

  604. 

  605. 	TEST_ASSERT(lilv_plugin_get_num_ports_of_class(plug, control_class, NULL) == 3);

  606. 	TEST_ASSERT(lilv_plugin_get_num_ports_of_class(plug, audio_class, NULL) == 0);

  607. 	TEST_ASSERT(lilv_plugin_get_num_ports_of_class(plug, in_class, NULL) == 2);

  608. 	TEST_ASSERT(lilv_plugin_get_num_ports_of_class(plug, out_class, NULL) == 1);

  609. 	TEST_ASSERT(lilv_plugin_get_num_ports_of_class(plug, control_class, in_class, NULL) == 2);

  610. 	TEST_ASSERT(lilv_plugin_get_num_ports_of_class(plug, control_class, out_class, NULL) == 1);

  611. 	TEST_ASSERT(lilv_plugin_get_num_ports_of_class(plug, audio_class, in_class, NULL) == 0);

  612. 	TEST_ASSERT(lilv_plugin_get_num_ports_of_class(plug, audio_class, out_class, NULL) == 0);

  613. 

  614. 	TEST_ASSERT(lilv_plugin_has_latency(plug));

  615. 	TEST_ASSERT(lilv_plugin_get_latency_port_index(plug) == 2);

  616. 

  617. 	LilvNode* lv2_latency = lilv_new_uri(world,

  618. 			"http://lv2plug.in/ns/lv2core#latency");

  619. 	LilvPort* latency_port = lilv_plugin_get_port_by_designation(

  620. 		plug, out_class, lv2_latency);

  621. 	lilv_node_free(lv2_latency);

  622. 

  623. 	TEST_ASSERT(latency_port);

  624. 	TEST_ASSERT(lilv_port_get_index(plug, latency_port) == 2);

  625. 

  626. 	LilvNode* rt_feature = lilv_new_uri(world,

  627. 			"http://lv2plug.in/ns/lv2core#hardRTCapable");

  628. 	LilvNode* event_feature = lilv_new_uri(world,

  629. 			"http://lv2plug.in/ns/ext/event");

  630. 	LilvNode* pretend_feature = lilv_new_uri(world,

  631. 			"http://example.org/solvesWorldHunger");

  632. 

  633. 	TEST_ASSERT(lilv_plugin_has_feature(plug, rt_feature));

  634. 	TEST_ASSERT(lilv_plugin_has_feature(plug, event_feature));

  635. 	TEST_ASSERT(!lilv_plugin_has_feature(plug, pretend_feature));

  636. 

  637. 	lilv_node_free(rt_feature);

  638. 	lilv_node_free(event_feature);

  639. 	lilv_node_free(pretend_feature);

  640. 

  641. 	LilvNodes* supported = lilv_plugin_get_supported_features(plug);

  642. 	LilvNodes* required = lilv_plugin_get_required_features(plug);

  643. 	LilvNodes* optional = lilv_plugin_get_optional_features(plug);

  644. 	TEST_ASSERT(lilv_nodes_size(supported) == 2);

  645. 	TEST_ASSERT(lilv_nodes_size(required) == 1);

  646. 	TEST_ASSERT(lilv_nodes_size(optional) == 1);

  647. 	lilv_nodes_free(supported);

  648. 	lilv_nodes_free(required);

  649. 	lilv_nodes_free(optional);

  650. 

  651. 	LilvNode*  foo_p = lilv_new_uri(world, "http://example.org/foo");

  652. 	LilvNodes* foos  = lilv_plugin_get_value(plug, foo_p);

  653. 	TEST_ASSERT(lilv_nodes_size(foos) == 1);

  654. 	TEST_ASSERT(fabs(lilv_node_as_float(lilv_nodes_get_first(foos)) - 1.6180) < FLT_EPSILON);

  655. 	lilv_node_free(foo_p);

  656. 	lilv_nodes_free(foos);

  657. 

  658. 	LilvNode*  bar_p = lilv_new_uri(world, "http://example.org/bar");

  659. 	LilvNodes* bars  = lilv_plugin_get_value(plug, bar_p);

  660. 	TEST_ASSERT(lilv_nodes_size(bars) == 1);

  661. 	TEST_ASSERT(lilv_node_as_bool(lilv_nodes_get_first(bars)) == true);

  662. 	lilv_node_free(bar_p);

  663. 	lilv_nodes_free(bars);

  664. 

  665. 	LilvNode*  baz_p = lilv_new_uri(world, "http://example.org/baz");

  666. 	LilvNodes* bazs  = lilv_plugin_get_value(plug, baz_p);

  667. 	TEST_ASSERT(lilv_nodes_size(bazs) == 1);

  668. 	TEST_ASSERT(lilv_node_as_bool(lilv_nodes_get_first(bazs)) == false);

  669. 	lilv_node_free(baz_p);

  670. 	lilv_nodes_free(bazs);

  671. 

  672. 	LilvNode*  blank_p = lilv_new_uri(world, "http://example.org/blank");

  673. 	LilvNodes* blanks  = lilv_plugin_get_value(plug, blank_p);

  674. 	TEST_ASSERT(lilv_nodes_size(blanks) == 1);

  675. 	LilvNode*  blank = lilv_nodes_get_first(blanks);

  676. 	TEST_ASSERT(lilv_node_is_blank(blank));

  677. 	const char* blank_str = lilv_node_as_blank(blank);

  678. 	char*       blank_tok = lilv_node_get_turtle_token(blank);

  679. 	TEST_ASSERT(!strncmp(blank_tok, "_:", 2));

  680. 	TEST_ASSERT(!strcmp(blank_tok + 2, blank_str));

  681. 	free(blank_tok);

  682. 	lilv_node_free(blank_p);

  683. 	lilv_nodes_free(blanks);

  684. 

  685. 	LilvNode* author_name = lilv_plugin_get_author_name(plug);

  686. 	TEST_ASSERT(!strcmp(lilv_node_as_string(author_name), "David Robillard"));

  687. 	lilv_node_free(author_name);

  688. 

  689. 	LilvNode* author_email = lilv_plugin_get_author_email(plug);

  690. 	TEST_ASSERT(!strcmp(lilv_node_as_string(author_email), "mailto:d@drobilla.net"));

  691. 	lilv_node_free(author_email);

  692. 

  693. 	LilvNode* author_homepage = lilv_plugin_get_author_homepage(plug);

  694. 	TEST_ASSERT(!strcmp(lilv_node_as_string(author_homepage), "http://drobilla.net"));

  695. 	lilv_node_free(author_homepage);

  696. 

  697. 	LilvNode* thing_uri = lilv_new_uri(world, "http://example.org/thing");

  698. 	LilvNode* name_p = lilv_new_uri(world, "http://usefulinc.com/ns/doap#name");

  699. 	LilvNodes* thing_names = lilv_world_find_nodes(world, thing_uri, name_p, NULL);

  700. 	TEST_ASSERT(lilv_nodes_size(thing_names) == 1);

  701. 	LilvNode* thing_name = lilv_nodes_get_first(thing_names);

  702. 	TEST_ASSERT(thing_name);

  703. 	TEST_ASSERT(lilv_node_is_string(thing_name));

  704. 	TEST_ASSERT(!strcmp(lilv_node_as_string(thing_name), "Something else"));

  705. 

  706. 	LilvUIs* uis = lilv_plugin_get_uis(plug);

  707. 	TEST_ASSERT(lilv_uis_size(uis) == 0);

  708. 	lilv_uis_free(uis);

  709. 

  710. 	LilvNode* extdata = lilv_new_uri(world, "http://example.org/extdata");

  711. 	LilvNode* noextdata = lilv_new_uri(world, "http://example.org/noextdata");

  712. 	LilvNodes* extdatas = lilv_plugin_get_extension_data(plug);

  713. 	TEST_ASSERT(lilv_plugin_has_extension_data(plug, extdata));

  714. 	TEST_ASSERT(!lilv_plugin_has_extension_data(plug, noextdata));

  715. 	TEST_ASSERT(lilv_nodes_size(extdatas) == 1);

  716. 	TEST_ASSERT(lilv_node_equals(lilv_nodes_get_first(extdatas), extdata));

  717. 	lilv_node_free(noextdata);

  718. 	lilv_node_free(extdata);

  719. 	lilv_nodes_free(extdatas);

  720. 

  721. 	lilv_nodes_free(thing_names);

  722. 	lilv_node_free(thing_uri);

  723. 	lilv_node_free(name_p);

  724. 	lilv_node_free(control_class);

  725. 	lilv_node_free(audio_class);

  726. 	lilv_node_free(in_class);

  727. 	lilv_node_free(out_class);

  728. 	cleanup_uris();

  729. 	return 1;

  730. }

  731. 

  732. /*****************************************************************************/

  733. 

  734. static int

  735. test_port(void)

  736. {

  737. 	if (!start_bundle(MANIFEST_PREFIXES

  738. 			":plug a lv2:Plugin ; lv2:binary <foo" SHLIB_EXT "> ; rdfs:seeAlso <plugin.ttl> .\n",

  739. 			BUNDLE_PREFIXES PREFIX_LV2EV

  740. 			":plug a lv2:Plugin ; "

  741. 			PLUGIN_NAME("Test plugin") " ; "

  742. 			LICENSE_GPL " ; "

  743. 			"doap:homepage <http://example.org/someplug> ; "

  744. 			"lv2:port [ "

  745. 			"  a lv2:ControlPort ; a lv2:InputPort ; "

  746. 			"  lv2:index 0 ; lv2:symbol \"foo\" ; "

  747. 			"  lv2:name \"store\" ; "

  748. 			"  lv2:name \"dépanneur\"@fr-ca ; lv2:name \"épicerie\"@fr-fr ; "

  749. 			"  lv2:name \"tienda\"@es ; "

  750. 			"  rdfs:comment \"comment\"@en , \"commentaires\"@fr ; "

  751.      		"  lv2:portProperty lv2:integer ; "

  752. 			"  lv2:minimum -1.0 ; lv2:maximum 1.0 ; lv2:default 0.5 ; "

  753. 			"  lv2:scalePoint [ rdfs:label \"Sin\"; rdf:value 3 ] ; "

  754. 			"  lv2:scalePoint [ rdfs:label \"Cos\"; rdf:value 4 ] "

  755. 			"] , [\n"

  756. 			"  a lv2:EventPort ; a lv2:InputPort ; "

  757. 			"  lv2:index 1 ; lv2:symbol \"event_in\" ; "

  758. 			"  lv2:name \"Event Input\" ; "

  759.      		"  lv2ev:supportsEvent <http://example.org/event> "

  760. 			"] ."))

  761. 		return 0;

  762. 

  763. 	init_uris();

  764. 	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);

  765. 	const LilvPlugin*  plug    = lilv_plugins_get_by_uri(plugins, plugin_uri_value);

  766. 	TEST_ASSERT(plug);

  767. 

  768. 	LilvNode*       psym = lilv_new_string(world, "foo");

  769. 	const LilvPort* p    = lilv_plugin_get_port_by_index(plug, 0);

  770. 	const LilvPort* p2   = lilv_plugin_get_port_by_symbol(plug, psym);

  771. 	lilv_node_free(psym);

  772. 	TEST_ASSERT(p != NULL);

  773. 	TEST_ASSERT(p2 != NULL);

  774. 	TEST_ASSERT(p == p2);

  775. 

  776. 	LilvNode*       nopsym = lilv_new_string(world, "thisaintnoportfoo");

  777. 	const LilvPort* p3     = lilv_plugin_get_port_by_symbol(plug, nopsym);

  778. 	TEST_ASSERT(p3 == NULL);

  779. 	lilv_node_free(nopsym);

  780. 

  781. 	LilvNode* audio_class = lilv_new_uri(world,

  782. 			"http://lv2plug.in/ns/lv2core#AudioPort");

  783. 	LilvNode* control_class = lilv_new_uri(world,

  784. 			"http://lv2plug.in/ns/lv2core#ControlPort");

  785. 	LilvNode* in_class = lilv_new_uri(world,

  786. 			"http://lv2plug.in/ns/lv2core#InputPort");

  787. 

  788. 	TEST_ASSERT(lilv_nodes_size(lilv_port_get_classes(plug, p)) == 2);

  789. 	TEST_ASSERT(lilv_plugin_get_num_ports(plug) == 2);

  790. 	TEST_ASSERT(lilv_port_is_a(plug, p, control_class));

  791. 	TEST_ASSERT(lilv_port_is_a(plug, p, in_class));

  792. 	TEST_ASSERT(!lilv_port_is_a(plug, p, audio_class));

  793. 

  794. 	LilvNodes* port_properties = lilv_port_get_properties(plug, p);

  795. 	TEST_ASSERT(lilv_nodes_size(port_properties) == 1);

  796. 	lilv_nodes_free(port_properties);

  797. 

  798. 	// Untranslated name (current locale is set to "C" in main)

  799. 	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_port_get_symbol(plug, p)), "foo"));

  800. 	LilvNode* name = lilv_port_get_name(plug, p);

  801. 	TEST_ASSERT(!strcmp(lilv_node_as_string(name), "store"));

  802. 	lilv_node_free(name);

  803. 

  804. 	// Exact language match

  805. 	setenv("LANG", "fr_FR", 1);

  806. 	name = lilv_port_get_name(plug, p);

  807. 	TEST_ASSERT(!strcmp(lilv_node_as_string(name), "épicerie"));

  808. 	lilv_node_free(name);

  809. 

  810. 	// Exact language match (with charset suffix)

  811. 	setenv("LANG", "fr_CA.utf8", 1);

  812. 	name = lilv_port_get_name(plug, p);

  813. 	TEST_ASSERT(!strcmp(lilv_node_as_string(name), "dépanneur"));

  814. 	lilv_node_free(name);

  815. 

  816. 	// Partial language match (choose value translated for different country)

  817. 	setenv("LANG", "fr_BE", 1);

  818. 	name = lilv_port_get_name(plug, p);

  819. 	TEST_ASSERT((!strcmp(lilv_node_as_string(name), "dépanneur"))

  820. 	            ||(!strcmp(lilv_node_as_string(name), "épicerie")));

  821. 	lilv_node_free(name);

  822. 

  823. 	// Partial language match (choose country-less language tagged value)

  824. 	setenv("LANG", "es_MX", 1);

  825. 	name = lilv_port_get_name(plug, p);

  826. 	TEST_ASSERT(!strcmp(lilv_node_as_string(name), "tienda"));

  827. 	lilv_node_free(name);

  828. 

  829. 	// No language match (choose untranslated value)

  830. 	setenv("LANG", "cn", 1);

  831. 	name = lilv_port_get_name(plug, p);

  832. 	TEST_ASSERT(!strcmp(lilv_node_as_string(name), "store"));

  833. 	lilv_node_free(name);

  834. 

  835. 	setenv("LANG", "en_CA.utf-8", 1);

  836. 

  837. 	// Language tagged value with no untranslated values

  838. 	LilvNode*  rdfs_comment = lilv_new_uri(world, LILV_NS_RDFS "comment");

  839. 	LilvNodes* comments     = lilv_port_get_value(plug, p, rdfs_comment);

  840. 	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_nodes_get_first(comments)),

  841. 	                    "comment"));

  842. 	lilv_nodes_free(comments);

  843. 

  844. 	setenv("LANG", "fr", 1);

  845. 

  846. 	comments = lilv_port_get_value(plug, p, rdfs_comment);

  847. 	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_nodes_get_first(comments)),

  848. 	                    "commentaires"));

  849. 	lilv_nodes_free(comments);

  850. 

  851. 	setenv("LANG", "cn", 1);

  852. 

  853. 	comments = lilv_port_get_value(plug, p, rdfs_comment);

  854. 	TEST_ASSERT(!comments);

  855. 	lilv_nodes_free(comments);

  856. 

  857. 	lilv_node_free(rdfs_comment);

  858. 

  859. 	setenv("LANG", "C", 1);  // Reset locale

  860. 

  861. 	LilvScalePoints* points = lilv_port_get_scale_points(plug, p);

  862. 	TEST_ASSERT(lilv_scale_points_size(points) == 2);

  863. 

  864. 	LilvIter* sp_iter = lilv_scale_points_begin(points);

  865. 	const LilvScalePoint* sp0 = lilv_scale_points_get(points, sp_iter);

  866. 	TEST_ASSERT(sp0);

  867. 	sp_iter = lilv_scale_points_next(points, sp_iter);

  868. 	const LilvScalePoint* sp1 = lilv_scale_points_get(points, sp_iter);

  869. 	TEST_ASSERT(sp1);

  870. 

  871. 	TEST_ASSERT(

  872. 		((!strcmp(lilv_node_as_string(lilv_scale_point_get_label(sp0)), "Sin")

  873. 		  && lilv_node_as_float(lilv_scale_point_get_value(sp0)) == 3)

  874. 		 &&

  875. 		 (!strcmp(lilv_node_as_string(lilv_scale_point_get_label(sp1)), "Cos")

  876. 		  && lilv_node_as_float(lilv_scale_point_get_value(sp1)) == 4))

  877. 		||

  878. 		((!strcmp(lilv_node_as_string(lilv_scale_point_get_label(sp0)), "Cos")

  879. 		  && lilv_node_as_float(lilv_scale_point_get_value(sp0)) == 4)

  880. 		 &&

  881. 		 (!strcmp(lilv_node_as_string(lilv_scale_point_get_label(sp1)), "Sin")

  882. 		  && lilv_node_as_float(lilv_scale_point_get_value(sp1)) == 3)));

  883. 

  884. 	LilvNode* homepage_p = lilv_new_uri(world, "http://usefulinc.com/ns/doap#homepage");

  885. 	LilvNodes* homepages = lilv_plugin_get_value(plug, homepage_p);

  886. 	TEST_ASSERT(lilv_nodes_size(homepages) == 1);

  887. 	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_nodes_get_first(homepages)),

  888. 			"http://example.org/someplug"));

  889. 

  890. 	LilvNode *min, *max, *def;

  891. 	lilv_port_get_range(plug, p, &def, &min, &max);

  892. 	TEST_ASSERT(def);

  893. 	TEST_ASSERT(min);

  894. 	TEST_ASSERT(max);

  895. 	TEST_ASSERT(lilv_node_as_float(def) == 0.5);

  896. 	TEST_ASSERT(lilv_node_as_float(min) == -1.0);

  897. 	TEST_ASSERT(lilv_node_as_float(max) == 1.0);

  898. 

  899. 	LilvNode* integer_prop = lilv_new_uri(world, "http://lv2plug.in/ns/lv2core#integer");

  900. 	LilvNode* toggled_prop = lilv_new_uri(world, "http://lv2plug.in/ns/lv2core#toggled");

  901. 

  902. 	TEST_ASSERT(lilv_port_has_property(plug, p, integer_prop));

  903. 	TEST_ASSERT(!lilv_port_has_property(plug, p, toggled_prop));

  904. 

  905. 	const LilvPort* ep = lilv_plugin_get_port_by_index(plug, 1);

  906. 

  907. 	LilvNode* event_type = lilv_new_uri(world, "http://example.org/event");

  908. 	LilvNode* event_type_2 = lilv_new_uri(world, "http://example.org/otherEvent");

  909. 	TEST_ASSERT(lilv_port_supports_event(plug, ep, event_type));

  910. 	TEST_ASSERT(!lilv_port_supports_event(plug, ep, event_type_2));

  911. 

  912. 	LilvNode* name_p = lilv_new_uri(world, "http://lv2plug.in/ns/lv2core#name");

  913. 	LilvNodes* names = lilv_port_get_value(plug, p, name_p);

  914. 	TEST_ASSERT(lilv_nodes_size(names) == 1);

  915. 	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_nodes_get_first(names)),

  916. 	                    "store"));

  917. 	lilv_nodes_free(names);

  918. 

  919. 	LilvNode* true_val  = lilv_new_bool(world, true);

  920. 	LilvNode* false_val = lilv_new_bool(world, false);

  921. 

  922. 	TEST_ASSERT(!lilv_node_equals(true_val, false_val));

  923. 

  924. 	lilv_world_set_option(world, LILV_OPTION_FILTER_LANG, false_val);

  925. 	names = lilv_port_get_value(plug, p, name_p);

  926. 	TEST_ASSERT(lilv_nodes_size(names) == 4);

  927. 	lilv_nodes_free(names);

  928. 	lilv_world_set_option(world, LILV_OPTION_FILTER_LANG, true_val);

  929. 

  930. 	lilv_node_free(false_val);

  931. 	lilv_node_free(true_val);

  932. 

  933. 	names = lilv_port_get_value(plug, ep, name_p);

  934. 	TEST_ASSERT(lilv_nodes_size(names) == 1);

  935. 	TEST_ASSERT(!strcmp(lilv_node_as_string(lilv_nodes_get_first(names)),

  936. 	                    "Event Input"));

  937. 	lilv_nodes_free(names);

  938. 	lilv_node_free(name_p);

  939. 

  940. 	lilv_node_free(integer_prop);

  941. 	lilv_node_free(toggled_prop);

  942. 	lilv_node_free(event_type);

  943. 	lilv_node_free(event_type_2);

  944. 

  945. 	lilv_node_free(min);

  946. 	lilv_node_free(max);

  947. 	lilv_node_free(def);

  948. 

  949. 	lilv_node_free(homepage_p);

  950. 	lilv_nodes_free(homepages);

  951. 

  952. 	lilv_scale_points_free(points);

  953. 	lilv_node_free(control_class);

  954. 	lilv_node_free(audio_class);

  955. 	lilv_node_free(in_class);

  956. 	cleanup_uris();

  957. 	return 1;

  958. }

  959. 

  960. /*****************************************************************************/

  961. 

  962. static unsigned

  963. ui_supported(const char* container_type_uri,

  964.              const char* ui_type_uri)

  965. {

  966. 	return !strcmp(container_type_uri, ui_type_uri);

  967. }

  968. 

  969. static int

  970. test_ui(void)

  971. {

  972. 	if (!start_bundle(MANIFEST_PREFIXES

  973. 			":plug a lv2:Plugin ; lv2:binary <foo" SHLIB_EXT "> ; rdfs:seeAlso <plugin.ttl> .\n",

  974. 			BUNDLE_PREFIXES PREFIX_LV2UI

  975. 			":plug a lv2:Plugin ; a lv2:CompressorPlugin ; "

  976. 			PLUGIN_NAME("Test plugin") " ; "

  977. 			LICENSE_GPL " ; "

  978. 			"lv2:optionalFeature lv2:hardRTCapable ; "

  979. 		    "lv2:requiredFeature <http://lv2plug.in/ns/ext/event> ; "

  980. 			"lv2ui:ui :ui , :ui2 , :ui3 , :ui4 ; "

  981. 			"doap:maintainer [ foaf:name \"David Robillard\" ; "

  982. 			"  foaf:homepage <http://drobilla.net> ; foaf:mbox <mailto:d@drobilla.net> ] ; "

  983. 			"lv2:port [ "

  984. 			"  a lv2:ControlPort ; a lv2:InputPort ; "

  985. 			"  lv2:index 0 ; lv2:symbol \"foo\" ; lv2:name \"bar\" ; "

  986. 			"  lv2:minimum -1.0 ; lv2:maximum 1.0 ; lv2:default 0.5 "

  987. 			"] , [ "

  988. 			"  a lv2:ControlPort ; a lv2:InputPort ; "

  989. 			"  lv2:index 1 ; lv2:symbol \"bar\" ; lv2:name \"Baz\" ; "

  990. 			"  lv2:minimum -2.0 ; lv2:maximum 2.0 ; lv2:default 1.0 "

  991. 			"] , [ "

  992. 			"  a lv2:ControlPort ; a lv2:OutputPort ; "

  993. 			"  lv2:index 2 ; lv2:symbol \"latency\" ; lv2:name \"Latency\" ; "

  994. 			"  lv2:portProperty lv2:reportsLatency "

  995. 			"] .\n"

  996. 			":ui a lv2ui:GtkUI ; "

  997. 			"  lv2ui:requiredFeature lv2ui:makeResident ; "

  998. 			"  lv2ui:binary <ui" SHLIB_EXT "> ; "

  999. 			"  lv2ui:optionalFeature lv2ui:ext_presets . "

  1000. 			":ui2 a lv2ui:GtkUI ; lv2ui:binary <ui2" SHLIB_EXT "> . "

  1001. 			":ui3 a lv2ui:GtkUI ; lv2ui:binary <ui3" SHLIB_EXT "> . "

  1002. 			":ui4 a lv2ui:GtkUI ; lv2ui:binary <ui4" SHLIB_EXT "> . "))

  1003. 		return 0;

  1004. 

  1005. 	init_uris();

  1006. 	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);

  1007. 	const LilvPlugin* plug = lilv_plugins_get_by_uri(plugins, plugin_uri_value);

  1008. 	TEST_ASSERT(plug);

  1009. 

  1010. 	LilvUIs* uis = lilv_plugin_get_uis(plug);

  1011. 	TEST_ASSERT(lilv_uis_size(uis) == 4);

  1012. 

  1013. 	const LilvUI* ui0 = lilv_uis_get(uis, lilv_uis_begin(uis));

  1014. 	TEST_ASSERT(ui0);

  1015. 

  1016. 	LilvNode* ui_uri = lilv_new_uri(world, "http://example.org/ui");

  1017. 	LilvNode* ui2_uri = lilv_new_uri(world, "http://example.org/ui3");

  1018. 	LilvNode* ui3_uri = lilv_new_uri(world, "http://example.org/ui4");

  1019. 	LilvNode* noui_uri = lilv_new_uri(world, "http://example.org/notaui");

  1020. 

  1021. 	const LilvUI* ui0_2 = lilv_uis_get_by_uri(uis, ui_uri);

  1022. 	TEST_ASSERT(ui0 == ui0_2);

  1023. 	TEST_ASSERT(lilv_node_equals(lilv_ui_get_uri(ui0_2), ui_uri));

  1024. 

  1025. 	const LilvUI* ui2 = lilv_uis_get_by_uri(uis, ui2_uri);

  1026. 	TEST_ASSERT(ui2 != ui0);

  1027. 

  1028. 	const LilvUI* ui3 = lilv_uis_get_by_uri(uis, ui3_uri);

  1029. 	TEST_ASSERT(ui3 != ui0);

  1030. 

  1031. 	const LilvUI* noui = lilv_uis_get_by_uri(uis, noui_uri);

  1032. 	TEST_ASSERT(noui == NULL);

  1033. 

  1034. 	const LilvNodes* classes = lilv_ui_get_classes(ui0);

  1035. 	TEST_ASSERT(lilv_nodes_size(classes) == 1);

  1036. 

  1037. 	LilvNode* ui_class_uri = lilv_new_uri(world,

  1038. 			"http://lv2plug.in/ns/extensions/ui#GtkUI");

  1039. 

  1040. 	TEST_ASSERT(lilv_node_equals(lilv_nodes_get_first(classes), ui_class_uri));

  1041. 	TEST_ASSERT(lilv_ui_is_a(ui0, ui_class_uri));

  1042. 

  1043. 	const LilvNode* ui_type = NULL;

  1044. 	TEST_ASSERT(lilv_ui_is_supported(ui0, ui_supported, ui_class_uri, &ui_type));

  1045. 	TEST_ASSERT(lilv_node_equals(ui_type, ui_class_uri));

  1046. 

  1047. 	const LilvNode* plug_bundle_uri = lilv_plugin_get_bundle_uri(plug);

  1048. 	const LilvNode* ui_bundle_uri   = lilv_ui_get_bundle_uri(ui0);

  1049. 	TEST_ASSERT(lilv_node_equals(plug_bundle_uri, ui_bundle_uri));

  1050. 

  1051. 	char* ui_binary_uri_str = (char*)malloc(TEST_PATH_MAX);

  1052. 	snprintf(ui_binary_uri_str, TEST_PATH_MAX, "%s%s",

  1053. 			lilv_node_as_string(plug_bundle_uri), "ui" SHLIB_EXT);

  1054. 

  1055. 	const LilvNode* ui_binary_uri = lilv_ui_get_binary_uri(ui0);

  1056. 

  1057. 	LilvNode* expected_uri = lilv_new_uri(world, ui_binary_uri_str);

  1058. 	TEST_ASSERT(lilv_node_equals(expected_uri, ui_binary_uri));

  1059. 

  1060. 	free(ui_binary_uri_str);

  1061. 	lilv_node_free(ui_class_uri);

  1062. 	lilv_node_free(ui_uri);

  1063. 	lilv_node_free(ui2_uri);

  1064. 	lilv_node_free(ui3_uri);

  1065. 	lilv_node_free(noui_uri);

  1066. 	lilv_node_free(expected_uri);

  1067. 	lilv_uis_free(uis);

  1068. 

  1069. 	cleanup_uris();

  1070. 	return 1;

  1071. }

  1072. 

  1073. /*****************************************************************************/

  1074. 

  1075. uint32_t atom_Float = 0;

  1076. float    in         = 1.0;

  1077. float    out        = 42.0;

  1078. 

  1079. static const void*

  1080. get_port_value(const char* port_symbol,

  1081.                void*       user_data,

  1082.                uint32_t*   size,

  1083.                uint32_t*   type)

  1084. {

  1085. 	if (!strcmp(port_symbol, "input")) {

  1086. 		*size = sizeof(float);

  1087. 		*type = atom_Float;

  1088. 		return &in;

  1089. 	} else if (!strcmp(port_symbol, "output")) {

  1090. 		*size = sizeof(float);

  1091. 		*type = atom_Float;

  1092. 		return &out;

  1093. 	} else {

  1094. 		fprintf(stderr, "error: get_port_value for nonexistent port `%s'\n",

  1095. 		        port_symbol);

  1096. 		*size = *type = 0;

  1097. 		return NULL;

  1098. 	}

  1099. }

  1100. 

  1101. static void

  1102. set_port_value(const char*     port_symbol,

  1103.                void*           user_data,

  1104.                const void*     value,

  1105.                uint32_t        size,

  1106.                uint32_t        type)

  1107. {

  1108. 	if (!strcmp(port_symbol, "input")) {

  1109. 		in = *(float*)value;

  1110. 	} else if (!strcmp(port_symbol, "output")) {

  1111. 		out = *(float*)value;

  1112. 	} else {

  1113. 		fprintf(stderr, "error: set_port_value for nonexistent port `%s'\n",

  1114. 		        port_symbol);

  1115. 	}

  1116. }

  1117. 

  1118. char** uris   = NULL;

  1119. size_t n_uris = 0;

  1120. 

  1121. static LV2_URID

  1122. map_uri(LV2_URID_Map_Handle handle,

  1123.         const char*         uri)

  1124. {

  1125. 	for (size_t i = 0; i < n_uris; ++i) {

  1126. 		if (!strcmp(uris[i], uri)) {

  1127. 			return i + 1;

  1128. 		}

  1129. 	}

  1130. 

  1131. 	assert(serd_uri_string_has_scheme((const uint8_t*)uri));

  1132. 	uris = (char**)realloc(uris, ++n_uris * sizeof(char*));

  1133. 	uris[n_uris - 1] = lilv_strdup(uri);

  1134. 	return n_uris;

  1135. }

  1136. 

  1137. static const char*

  1138. unmap_uri(LV2_URID_Map_Handle handle,

  1139.           LV2_URID            urid)

  1140. {

  1141. 	if (urid > 0 && urid <= n_uris) {

  1142. 		return uris[urid - 1];

  1143. 	}

  1144. 	return NULL;

  1145. }

  1146. 

  1147. static char* temp_dir = NULL;

  1148. 

  1149. static char*

  1150. lilv_make_path(LV2_State_Make_Path_Handle handle,

  1151.                const char*                path)

  1152. {

  1153. 	return lilv_path_join(temp_dir, path);

  1154. }

  1155. 

  1156. static int

  1157. test_state(void)

  1158. {

  1159. 	init_world();

  1160. 

  1161. 	uint8_t*   abs_bundle = (uint8_t*)lilv_path_absolute(LILV_TEST_BUNDLE);

  1162. 	SerdNode   bundle     = serd_node_new_file_uri(abs_bundle, 0, 0, true);

  1163. 	LilvNode*  bundle_uri = lilv_new_uri(world, (const char*)bundle.buf);

  1164. 	LilvNode*  plugin_uri = lilv_new_uri(world,

  1165. 	                                     "http://example.org/lilv-test-plugin");

  1166. 	lilv_world_load_bundle(world, bundle_uri);

  1167. 	free(abs_bundle);

  1168. 	serd_node_free(&bundle);

  1169. 

  1170. 	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);

  1171. 	const LilvPlugin*  plugin  = lilv_plugins_get_by_uri(plugins, plugin_uri);

  1172. 	TEST_ASSERT(plugin);

  1173. 

  1174. 	LV2_URID_Map       map           = { NULL, map_uri };

  1175. 	LV2_Feature        map_feature   = { LV2_URID_MAP_URI, &map };

  1176. 	LV2_URID_Unmap     unmap         = { NULL, unmap_uri };

  1177. 	LV2_Feature        unmap_feature = { LV2_URID_UNMAP_URI, &unmap };

  1178. 	const LV2_Feature* features[]    = { &map_feature, &unmap_feature, NULL };

  1179. 

  1180. 	atom_Float = map.map(map.handle, "http://lv2plug.in/ns/ext/atom#Float");

  1181. 

  1182. 	LilvNode*  num     = lilv_new_int(world, 5);

  1183. 	LilvState* nostate = lilv_state_new_from_file(world, &map, num, "/junk");

  1184. 	TEST_ASSERT(!nostate);

  1185. 

  1186. 	LilvInstance* instance = lilv_plugin_instantiate(plugin, 48000.0, features);

  1187. 	TEST_ASSERT(instance);

  1188. 	lilv_instance_activate(instance);

  1189. 	lilv_instance_connect_port(instance, 0, &in);

  1190. 	lilv_instance_connect_port(instance, 1, &out);

  1191. 	lilv_instance_run(instance, 1);

  1192. 	TEST_ASSERT(in == 1.0);

  1193. 	TEST_ASSERT(out == 1.0);

  1194. 

  1195. 	temp_dir = lilv_realpath("temp");

  1196. 

  1197. 	const char* file_dir = NULL;

  1198. 	char*       copy_dir = NULL;

  1199. 	char*       link_dir = NULL;

  1200. 	char*       save_dir = NULL;

  1201. 

  1202. 	// Get instance state state

  1203. 	LilvState* state = lilv_state_new_from_instance(

  1204. 		plugin, instance, &map,

  1205. 		file_dir, copy_dir, link_dir, save_dir,

  1206. 		get_port_value, world, 0, NULL);

  1207. 

  1208. 	// Get another instance state

  1209. 	LilvState* state2 = lilv_state_new_from_instance(

  1210. 		plugin, instance, &map,

  1211. 		file_dir, copy_dir, link_dir, save_dir,

  1212. 		get_port_value, world, 0, NULL);

  1213. 

  1214. 	// Ensure they are equal

  1215. 	TEST_ASSERT(lilv_state_equals(state, state2));

  1216. 

  1217. 	// Save state to a string

  1218. 	char* state1_str = lilv_state_to_string(

  1219. 		world, &map, &unmap, state, "http://example.org/state1", NULL);

  1220. 

  1221. 	// Restore from string

  1222. 	LilvState* from_str = lilv_state_new_from_string(world, &map, state1_str);

  1223. 

  1224. 	// Ensure they are equal

  1225. 	TEST_ASSERT(lilv_state_equals(state, from_str));

  1226. 	free(state1_str);

  1227. 

  1228. 	const LilvNode* state_plugin_uri = lilv_state_get_plugin_uri(state);

  1229. 	TEST_ASSERT(lilv_node_equals(state_plugin_uri, plugin_uri));

  1230. 

  1231. 	// Tinker with the label of the first state

  1232. 	TEST_ASSERT(lilv_state_get_label(state) == NULL);

  1233. 	lilv_state_set_label(state, "Test State Old Label");

  1234. 	TEST_ASSERT(!strcmp(lilv_state_get_label(state), "Test State Old Label"));

  1235. 	lilv_state_set_label(state, "Test State");

  1236. 	TEST_ASSERT(!strcmp(lilv_state_get_label(state), "Test State"));

  1237. 

  1238. 	TEST_ASSERT(!lilv_state_equals(state, state2));  // Label changed

  1239. 

  1240. 	// Run and get a new instance state (which should now differ)

  1241. 	lilv_instance_run(instance, 1);

  1242. 	LilvState* state3 = lilv_state_new_from_instance(

  1243. 		plugin, instance, &map,

  1244. 		file_dir, copy_dir, link_dir, save_dir,

  1245. 		get_port_value, world, 0, NULL);

  1246. 	TEST_ASSERT(!lilv_state_equals(state2, state3));  // num_runs changed

  1247. 

  1248. 	// Restore instance state to original state

  1249. 	lilv_state_restore(state2, instance, set_port_value, NULL, 0, NULL);

  1250. 

  1251. 	// Take a new snapshot and ensure it matches the set state

  1252. 	LilvState* state4 = lilv_state_new_from_instance(

  1253. 		plugin, instance, &map,

  1254. 		file_dir, copy_dir, link_dir, save_dir,

  1255. 		get_port_value, world, 0, NULL);

  1256. 	TEST_ASSERT(lilv_state_equals(state2, state4));

  1257. 

  1258. 	// Save state to a directory

  1259. 	int ret = lilv_state_save(world, &map, &unmap, state, NULL,

  1260. 	                          "state.lv2", "state.ttl");

  1261. 	TEST_ASSERT(!ret);

  1262. 

  1263. 	// Load state from directory

  1264. 	LilvState* state5 = lilv_state_new_from_file(world, &map, NULL,

  1265. 	                                             "state.lv2/state.ttl");

  1266. 

  1267. 	TEST_ASSERT(lilv_state_equals(state, state5));  // Round trip accuracy

  1268. 

  1269. 	// Save state with URI to a directory

  1270. 	const char* state_uri = "http://example.org/state";

  1271. 	ret = lilv_state_save(world, &map, &unmap, state, state_uri,

  1272. 	                      "state6.lv2", "state6.ttl");

  1273. 	TEST_ASSERT(!ret);

  1274. 

  1275. 	// Load default bundle into world and load state from it

  1276. 	uint8_t*  state6_path       = (uint8_t*)lilv_path_absolute("state6.lv2/");

  1277. 	SerdNode  state6_uri        = serd_node_new_file_uri(state6_path, 0, 0, true);

  1278. 	LilvNode* test_state_bundle = lilv_new_uri(world, (const char*)state6_uri.buf);

  1279. 	LilvNode* test_state_node   = lilv_new_uri(world, state_uri);

  1280. 	lilv_world_load_bundle(world, test_state_bundle);

  1281. 	lilv_world_load_resource(world, test_state_node);

  1282. 	serd_node_free(&state6_uri);

  1283. 	free(state6_path);

  1284. 

  1285. 	LilvState* state6 = lilv_state_new_from_world(world, &map, test_state_node);

  1286. 	TEST_ASSERT(lilv_state_equals(state, state6));  // Round trip accuracy

  1287. 	lilv_node_free(test_state_bundle);

  1288. 	lilv_node_free(test_state_node);

  1289. 

  1290. 	unsetenv("LV2_STATE_BUNDLE");

  1291. 

  1292. 	// Make directories and test files support

  1293. 	mkdir("temp", 0700);

  1294. 	file_dir = temp_dir;

  1295. 	mkdir("files", 0700);

  1296. 	copy_dir = lilv_realpath("files");

  1297. 	mkdir("links", 0700);

  1298. 	link_dir = lilv_realpath("links");

  1299. 

  1300. 	LV2_State_Make_Path make_path         = { NULL, lilv_make_path };

  1301. 	LV2_Feature         make_path_feature = { LV2_STATE__makePath, &make_path };

  1302. 	const LV2_Feature*  ffeatures[]       = { &make_path_feature, &map_feature, NULL };

  1303. 

  1304. 	lilv_instance_deactivate(instance);

  1305. 	lilv_instance_free(instance);

  1306. 	instance = lilv_plugin_instantiate(plugin, 48000.0, ffeatures);

  1307. 	lilv_instance_activate(instance);

  1308. 	lilv_instance_connect_port(instance, 0, &in);

  1309. 	lilv_instance_connect_port(instance, 1, &out);

  1310. 	lilv_instance_run(instance, 1);

  1311. 

  1312. 	// Get instance state state

  1313. 	LilvState* fstate = lilv_state_new_from_instance(

  1314. 		plugin, instance, &map,

  1315. 		file_dir, copy_dir, link_dir, "fstate.lv2",

  1316. 		get_port_value, world, 0, ffeatures);

  1317. 

  1318. 	// Get another instance state

  1319. 	LilvState* fstate2 = lilv_state_new_from_instance(

  1320. 		plugin, instance, &map,

  1321. 		file_dir, copy_dir, link_dir, "fstate2.lv2",

  1322. 		get_port_value, world, 0, ffeatures);

  1323. 

  1324. 	// Should be identical

  1325. 	TEST_ASSERT(lilv_state_equals(fstate, fstate2));

  1326. 

  1327. 	// Run, writing more to rec file

  1328. 	lilv_instance_run(instance, 2);

  1329. 

  1330. 	// Get yet another instance state

  1331. 	LilvState* fstate3 = lilv_state_new_from_instance(

  1332. 		plugin, instance, &map, file_dir, copy_dir, link_dir, "fstate3.lv2",

  1333. 		get_port_value, world, 0, ffeatures);

  1334. 

  1335. 	// Should be different

  1336. 	TEST_ASSERT(!lilv_state_equals(fstate, fstate3));

  1337. 

  1338. 	// Save state to a directory

  1339. 	ret = lilv_state_save(world, &map, &unmap, fstate, NULL,

  1340. 	                      "fstate.lv2", "fstate.ttl");

  1341. 	TEST_ASSERT(!ret);

  1342. 

  1343. 	// Load state from directory

  1344. 	LilvState* fstate4 = lilv_state_new_from_file(world, &map, NULL,

  1345. 	                                              "fstate.lv2/fstate.ttl");

  1346. 	TEST_ASSERT(lilv_state_equals(fstate, fstate4));  // Round trip accuracy

  1347. 

  1348. 	// Restore instance state to loaded state

  1349. 	lilv_state_restore(fstate4, instance, set_port_value, NULL, 0, ffeatures);

  1350. 

  1351. 	// Take a new snapshot and ensure it matches

  1352. 	LilvState* fstate5 = lilv_state_new_from_instance(

  1353. 		plugin, instance, &map,

  1354. 		file_dir, copy_dir, link_dir, "fstate5.lv2",

  1355. 		get_port_value, world, 0, ffeatures);

  1356. 	TEST_ASSERT(lilv_state_equals(fstate3, fstate5));

  1357. 

  1358. 	// Save state to a (different) directory again

  1359. 	ret = lilv_state_save(world, &map, &unmap, fstate, NULL,

  1360. 	                      "fstate6.lv2", "fstate6.ttl");

  1361. 	TEST_ASSERT(!ret);

  1362. 

  1363. 	// Reload it and ensure it's identical to the other loaded version

  1364. 	LilvState* fstate6 = lilv_state_new_from_file(world, &map, NULL,

  1365. 	                                              "fstate6.lv2/fstate6.ttl");

  1366. 	TEST_ASSERT(lilv_state_equals(fstate4, fstate6));

  1367. 

  1368. 	// Run, changing rec file (without changing size)

  1369. 	lilv_instance_run(instance, 3);

  1370. 

  1371. 	// Take a new snapshot

  1372. 	LilvState* fstate7 = lilv_state_new_from_instance(

  1373. 		plugin, instance, &map,

  1374. 		file_dir, copy_dir, link_dir, "fstate7.lv2",

  1375. 		get_port_value, world, 0, ffeatures);

  1376. 	TEST_ASSERT(!lilv_state_equals(fstate6, fstate7));

  1377. 

  1378. 	// Save the changed state to a (different) directory again

  1379. 	ret = lilv_state_save(world, &map, &unmap, fstate7, NULL,

  1380. 	                      "fstate7.lv2", "fstate7.ttl");

  1381. 	TEST_ASSERT(!ret);

  1382. 

  1383. 	// Reload it and ensure it's changed

  1384. 	LilvState* fstate72 = lilv_state_new_from_file(world, &map, NULL,

  1385. 	                                              "fstate7.lv2/fstate7.ttl");

  1386. 	TEST_ASSERT(lilv_state_equals(fstate72, fstate7));

  1387. 	TEST_ASSERT(!lilv_state_equals(fstate6, fstate72));

  1388. 

  1389. 	lilv_instance_deactivate(instance);

  1390. 	lilv_instance_free(instance);

  1391. 

  1392. 	lilv_node_free(num);

  1393. 

  1394. 	lilv_state_free(state);

  1395. 	lilv_state_free(from_str);

  1396. 	lilv_state_free(state2);

  1397. 	lilv_state_free(state3);

  1398. 	lilv_state_free(state4);

  1399. 	lilv_state_free(state5);

  1400. 	lilv_state_free(state6);

  1401. 	lilv_state_free(fstate);

  1402. 	lilv_state_free(fstate2);

  1403. 	lilv_state_free(fstate3);

  1404. 	lilv_state_free(fstate4);

  1405. 	lilv_state_free(fstate5);

  1406. 	lilv_state_free(fstate6);

  1407. 	lilv_state_free(fstate7);

  1408. 	lilv_state_free(fstate72);

  1409. 

  1410. 	// Free URI map

  1411. 	for (size_t i = 0; i < n_uris; ++i) {

  1412. 		free(uris[i]);

  1413. 	}

  1414. 	free(uris);

  1415. 	n_uris = 0;

  1416. 

  1417. 	lilv_node_free(plugin_uri);

  1418. 	lilv_node_free(bundle_uri);

  1419. 	free(link_dir);

  1420. 	free(copy_dir);

  1421. 	free(temp_dir);

  1422. 

  1423. 	cleanup_uris();

  1424. 	return 1;

  1425. }

  1426. 

  1427. /*****************************************************************************/

  1428. 

  1429. static int

  1430. test_bad_port_symbol(void)

  1431. {

  1432. 	if (!start_bundle(MANIFEST_PREFIXES

  1433. 			":plug a lv2:Plugin ; lv2:binary <foo" SHLIB_EXT "> ; rdfs:seeAlso <plugin.ttl> .\n",

  1434. 			BUNDLE_PREFIXES PREFIX_LV2EV

  1435. 			":plug a lv2:Plugin ; "

  1436. 			PLUGIN_NAME("Test plugin") " ; "

  1437. 			LICENSE_GPL " ; "

  1438. 			"doap:homepage <http://example.org/someplug> ; "

  1439. 			"lv2:port [ "

  1440. 			"  a lv2:ControlPort ; a lv2:InputPort ; "

  1441. 			"  lv2:index 0 ; lv2:symbol \"0invalid\" ;"

  1442. 			"  lv2:name \"Invalid\" ; "

  1443. 			"] ."))

  1444. 		return 0;

  1445. 

  1446. 	init_uris();

  1447. 

  1448. 	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);

  1449. 	const LilvPlugin*  plug    = lilv_plugins_get_by_uri(plugins, plugin_uri_value);

  1450. 

  1451. 	uint32_t n_ports = lilv_plugin_get_num_ports(plug);

  1452. 	TEST_ASSERT(n_ports == 0);

  1453. 

  1454. 	cleanup_uris();

  1455. 	return 1;

  1456. }

  1457. 

  1458. /*****************************************************************************/

  1459. 

  1460. static int

  1461. test_bad_port_index(void)

  1462. {

  1463. 	if (!start_bundle(MANIFEST_PREFIXES

  1464. 			":plug a lv2:Plugin ; lv2:binary <foo" SHLIB_EXT "> ; rdfs:seeAlso <plugin.ttl> .\n",

  1465. 			BUNDLE_PREFIXES PREFIX_LV2EV

  1466. 			":plug a lv2:Plugin ; "

  1467. 			PLUGIN_NAME("Test plugin") " ; "

  1468. 			LICENSE_GPL " ; "

  1469. 			"doap:homepage <http://example.org/someplug> ; "

  1470. 			"lv2:port [ "

  1471. 			"  a lv2:ControlPort ; a lv2:InputPort ; "

  1472. 			"  lv2:index \"notaninteger\" ; lv2:symbol \"invalid\" ;"

  1473. 			"  lv2:name \"Invalid\" ; "

  1474. 			"] ."))

  1475. 		return 0;

  1476. 

  1477. 	init_uris();

  1478. 

  1479. 	const LilvPlugins* plugins = lilv_world_get_all_plugins(world);

  1480. 	const LilvPlugin*  plug    = lilv_plugins_get_by_uri(plugins, plugin_uri_value);

  1481. 

  1482. 	uint32_t n_ports = lilv_plugin_get_num_ports(plug);

  1483. 	TEST_ASSERT(n_ports == 0);

  1484. 

  1485. 	cleanup_uris();

  1486. 	return 1;

  1487. }

  1488. 

  1489. /*****************************************************************************/

  1490. 

  1491. static int

  1492. test_string(void)

  1493. {

  1494. 	char* s = NULL;

  1495. 

  1496. 	TEST_ASSERT(!strcmp((s = lilv_dirname("/foo/bar")), "/foo")); free(s);

  1497. 	TEST_ASSERT(!strcmp((s = lilv_dirname("/foo/bar/")), "/foo")); free(s);

  1498. 	TEST_ASSERT(!strcmp((s = lilv_dirname("/foo///bar/")), "/foo")); free(s);

  1499. 	TEST_ASSERT(!strcmp((s = lilv_dirname("/foo///bar//")), "/foo")); free(s);

  1500. 	TEST_ASSERT(!strcmp((s = lilv_dirname("foo")), ".")); free(s);

  1501. 	TEST_ASSERT(!strcmp((s = lilv_dirname("/foo")), "/")); free(s);

  1502. 	TEST_ASSERT(!strcmp((s = lilv_dirname("/")), "/")); free(s);

  1503. 	TEST_ASSERT(!strcmp((s = lilv_dirname("//")), "/")); free(s);

  1504. 	TEST_ASSERT(!strcmp((s = lilv_path_relative_to("/a/b", "/a/")), "b")); free(s);

  1505. 	TEST_ASSERT(!strcmp((s = lilv_path_relative_to("/a", "/b/c/")), "/a")); free(s);

  1506. 	TEST_ASSERT(!strcmp((s = lilv_path_relative_to("/a/b/c", "/a/b/d/")), "../c")); free(s);

  1507. 	TEST_ASSERT(!strcmp((s = lilv_path_relative_to("/a/b/c", "/a/b/d/e/")), "../../c")); free(s);

  1508. 	TEST_ASSERT(!strcmp((s = lilv_path_join("/a", "b")), "/a/b")); free(s);

  1509. 	TEST_ASSERT(!strcmp((s = lilv_path_join("/a", "/b")), "/a/b")); free(s);

  1510. 	TEST_ASSERT(!strcmp((s = lilv_path_join("/a/", "/b")), "/a/b")); free(s);

  1511. 	TEST_ASSERT(!strcmp((s = lilv_path_join("/a/", "b")), "/a/b")); free(s);

  1512. 	TEST_ASSERT(!strcmp((s = lilv_path_join("/a", NULL)), "/a/")); free(s);

  1513. 

  1514. #ifndef _WIN32

  1515. 	setenv("LILV_TEST_1", "test", 1);

  1516. 	char* home_foo = lilv_strjoin(getenv("HOME"), "/foo", NULL);

  1517. 	TEST_ASSERT(!strcmp((s = lilv_expand("$LILV_TEST_1")), "test")); free(s);

  1518. 	TEST_ASSERT(!strcmp((s = lilv_expand("~")), getenv("HOME"))); free(s);

  1519. 	TEST_ASSERT(!strcmp((s = lilv_expand("~foo")), "~foo")); free(s);

  1520. 	TEST_ASSERT(!strcmp((s = lilv_expand("~/foo")), home_foo)); free(s);

  1521. 	TEST_ASSERT(!strcmp((s = lilv_expand("$NOT_A_VAR")), "$NOT_A_VAR")); free(s);

  1522. 	free(home_foo);

  1523. 	unsetenv("LILV_TEST_1");

  1524. #endif

  1525. 

  1526. 	return 1;

  1527. }

  1528. 

  1529. /*****************************************************************************/

  1530. 

  1531. /* add tests here */

  1532. static struct TestCase tests[] = {

  1533. 	TEST_CASE(utils),

  1534. 	TEST_CASE(value),

  1535. 	TEST_CASE(verify),

  1536. 	TEST_CASE(no_verify),

  1537. 	TEST_CASE(discovery),

  1538. 	TEST_CASE(lv2_path),

  1539. 	TEST_CASE(classes),

  1540. 	TEST_CASE(plugin),

  1541. 	TEST_CASE(port),

  1542. 	TEST_CASE(ui),

  1543. 	TEST_CASE(bad_port_symbol),

  1544. 	TEST_CASE(bad_port_index),

  1545. 	TEST_CASE(bad_port_index),

  1546. 	TEST_CASE(string),

  1547. 	TEST_CASE(state),

  1548. 	{ NULL, NULL }

  1549. };

  1550. 

  1551. static void

  1552. run_tests(void)

  1553. {

  1554. 	int i;

  1555. 	for (i = 0; tests[i].title; i++) {

  1556. 		printf("*** Test %s\n", tests[i].title);

  1557. 		if (!tests[i].func()) {

  1558. 			printf("\nTest failed\n");

  1559. 			/* test case that wasn't able to be executed at all counts as 1 test + 1 error */

  1560. 			error_count++;

  1561. 			test_count++;

  1562. 		}

  1563. 		unload_bundle();

  1564. 		cleanup();

  1565. 	}

  1566. }

  1567. 

  1568. int

  1569. main(int argc, char* argv[])

  1570. {

  1571. 	if (argc != 1) {

  1572. 		printf("Syntax: %s\n", argv[0]);

  1573. 		return 0;

  1574. 	}

  1575. 	setenv("LANG", "C", 1);

  1576. 	init_tests();

  1577. 	run_tests();

  1578. 	cleanup();

  1579. 	printf("\n*** Test Results: %d tests, %d errors\n\n", test_count, error_count);

  1580. 	return error_count ? 1 : 0;

  1581. }