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.
933 Commits
16 Branches
16GB
Tree: fb61ca773d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'fb61ca773d'
${ noResults }
Carla/source/modules/lilv/lilv-0.16.0/test/lilv_test.c

1610 lines
52KB
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_ATOM "@prefix atom: <http://lv2plug.in/ns/ext/atom#> . \n"

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

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

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

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

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

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

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

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

  182. 

  183. #define MANIFEST_PREFIXES PREFIX_LINE PREFIX_LV2 PREFIX_RDFS

  184. #define BUNDLE_PREFIXES PREFIX_ATOM PREFIX_LINE PREFIX_LV2 PREFIX_RDF PREFIX_RDFS PREFIX_FOAF PREFIX_DOAP

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

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

  187. 

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

  189. static LilvNode* plugin_uri_value;

  190. static LilvNode* plugin2_uri_value;

  191. 

  192. /*****************************************************************************/

  193. 

  194. static void

  195. init_uris(void)

  196. {

  197. 	plugin_uri_value = lilv_new_uri(world, uris_plugin);

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

  199. 	TEST_ASSERT(plugin_uri_value);

  200. 	TEST_ASSERT(plugin2_uri_value);

  201. }

  202. 

  203. static void

  204. cleanup_uris(void)

  205. {

  206. 	lilv_node_free(plugin2_uri_value);

  207. 	lilv_node_free(plugin_uri_value);

  208. 	plugin2_uri_value = NULL;

  209. 	plugin_uri_value = NULL;

  210. }

  211. 

  212. /*****************************************************************************/

  213. 

  214. static int

  215. test_utils(void)

  216. {

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

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

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

  220. 	return 1;

  221. }

  222. 

  223. /*****************************************************************************/

  224. 

  225. static int

  226. test_value(void)

  227. {

  228. 	if (!start_bundle(MANIFEST_PREFIXES

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

  230. 			BUNDLE_PREFIXES

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

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

  233. 			LICENSE_GPL " ; "

  234. 			"lv2:port [ "

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

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

  237. 			"] ."))

  238. 		return 0;

  239. 

  240. 	init_uris();

  241. 

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

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

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

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

  246. 

  247. 	TEST_ASSERT(lilv_node_is_uri(uval));

  248. 	TEST_ASSERT(lilv_node_is_string(sval));

  249. 	TEST_ASSERT(lilv_node_is_int(ival));

  250. 	TEST_ASSERT(lilv_node_is_float(fval));

  251. 

  252. 	TEST_ASSERT(!lilv_node_is_literal(uval));

  253. 	TEST_ASSERT(lilv_node_is_literal(sval));

  254. 	TEST_ASSERT(lilv_node_is_literal(ival));

  255. 	TEST_ASSERT(lilv_node_is_literal(fval));

  256. 

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

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

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

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

  261. 

  262. 	char* tok = lilv_node_get_turtle_token(uval);

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

  264. 	free(tok);

  265. 	tok = lilv_node_get_turtle_token(sval);

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

  267. 	free(tok);

  268. 	tok = lilv_node_get_turtle_token(ival);

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

  270. 	free(tok);

  271. 	tok = lilv_node_get_turtle_token(fval);

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

  273. 	free(tok);

  274. 

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

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

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

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

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

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

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

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

  283. 

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

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

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

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

  288. 

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

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

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

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

  293. 

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

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

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

  297. 

  298. 	LilvNode* uval_dup = lilv_node_duplicate(uval);

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

  300. 

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

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

  303. 	lilv_node_free(ifval);

  304. 

  305. 	LilvNode* nil = NULL;

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

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

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

  309. 

  310. 	LilvNode* nil2 = lilv_node_duplicate(nil);

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

  312. 

  313. 	lilv_node_free(uval);

  314. 	lilv_node_free(sval);

  315. 	lilv_node_free(ival);

  316. 	lilv_node_free(fval);

  317. 	lilv_node_free(uval_e);

  318. 	lilv_node_free(sval_e);

  319. 	lilv_node_free(ival_e);

  320. 	lilv_node_free(fval_e);

  321. 	lilv_node_free(uval_ne);

  322. 	lilv_node_free(sval_ne);

  323. 	lilv_node_free(ival_ne);

  324. 	lilv_node_free(fval_ne);

  325. 	lilv_node_free(uval_dup);

  326. 	lilv_node_free(nil2);

  327. 

  328. 	cleanup_uris();

  329. 	return 1;

  330. }

  331. 

  332. /*****************************************************************************/

  333. 

  334. static int discovery_plugin_found = 0;

  335. 

  336. static void

  337. discovery_verify_plugin(const LilvPlugin* plugin)

  338. {

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

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

  341. 		const LilvNode* lib_uri = NULL;

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

  343. 		discovery_plugin_found = 1;

  344. 		lib_uri = lilv_plugin_get_library_uri(plugin);

  345. 		TEST_ASSERT(lib_uri);

  346. 		TEST_ASSERT(lilv_node_is_uri(lib_uri));

  347. 		TEST_ASSERT(lilv_node_as_uri(lib_uri));

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

  349. 		TEST_ASSERT(lilv_plugin_verify(plugin));

  350. 	}

  351. }

  352. 

  353. static int

  354. test_discovery(void)

  355. {

  356. 	if (!start_bundle(MANIFEST_PREFIXES

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

  358. 			BUNDLE_PREFIXES

  359. 			":plug a lv2:Plugin ;"

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

  361. 			LICENSE_GPL " ; "

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

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

  364. 		return 0;

  365. 

  366. 	init_uris();

  367. 

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

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

  370. 

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

  372. 	TEST_ASSERT(explug != NULL);

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

  374. 	TEST_ASSERT(explug2 == NULL);

  375. 

  376. 	if (explug) {

  377. 		LilvNode* name = lilv_plugin_get_name(explug);

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

  379. 		lilv_node_free(name);

  380. 	}

  381. 

  382. 	discovery_plugin_found = 0;

  383. 	LILV_FOREACH(plugins, i, plugins)

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

  385. 

  386. 	TEST_ASSERT(discovery_plugin_found);

  387. 	plugins = NULL;

  388. 

  389. 	cleanup_uris();

  390. 

  391. 	return 1;

  392. }

  393. 

  394. /*****************************************************************************/

  395. 

  396. static int

  397. test_lv2_path(void)

  398. {

  399. #ifndef _WIN32

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

  401. 

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

  403. 

  404. 	world = lilv_world_new();

  405. 	lilv_world_load_all(world);

  406. 

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

  408. 	const size_t n_plugins     = lilv_plugins_size(plugins);

  409. 

  410. 	lilv_world_free(world);

  411. 

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

  413. 	world = lilv_world_new();

  414. 	lilv_world_load_all(world);

  415. 	plugins = lilv_world_get_all_plugins(world);

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

  417. 	lilv_world_free(world);

  418. 	world = NULL;

  419. 

  420. 	if (orig_lv2_path) {

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

  422. 	} else {

  423. 		unsetenv("LV2_PATH");

  424. 	}

  425. 	free(orig_lv2_path);

  426. #endif

  427. 	return 1;

  428. }

  429. 

  430. /*****************************************************************************/

  431. 

  432. static int

  433. test_verify(void)

  434. {

  435. 	if (!start_bundle(MANIFEST_PREFIXES

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

  437. 			BUNDLE_PREFIXES

  438. 			":plug a lv2:Plugin ; "

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

  440. 			LICENSE_GPL " ; "

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

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

  443. 		return 0;

  444. 

  445. 	init_uris();

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

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

  448. 	TEST_ASSERT(explug);

  449. 	TEST_ASSERT(lilv_plugin_verify(explug));

  450. 	cleanup_uris();

  451. 	return 1;

  452. }

  453. 

  454. /*****************************************************************************/

  455. 

  456. static int

  457. test_no_verify(void)

  458. {

  459. 	if (!start_bundle(MANIFEST_PREFIXES

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

  461. 			BUNDLE_PREFIXES

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

  463. 		return 0;

  464. 

  465. 	init_uris();

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

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

  468. 	TEST_ASSERT(explug);

  469. 	TEST_ASSERT(!lilv_plugin_verify(explug));

  470. 	cleanup_uris();

  471. 	return 1;

  472. }

  473. 

  474. /*****************************************************************************/

  475. 

  476. static int

  477. test_classes(void)

  478. {

  479. 	if (!start_bundle(MANIFEST_PREFIXES

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

  481. 			BUNDLE_PREFIXES

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

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

  484. 			LICENSE_GPL " ; "

  485. 			"lv2:port [ "

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

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

  488. 			"] ."))

  489. 		return 0;

  490. 

  491. 	init_uris();

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

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

  494. 	LilvPluginClasses*       children = lilv_plugin_class_get_children(plugin);

  495. 

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

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

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

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

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

  501. 

  502. 	LILV_FOREACH(plugin_classes, i, children) {

  503. 		TEST_ASSERT(lilv_node_equals(

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

  505. 				lilv_plugin_class_get_uri(plugin)));

  506. 	}

  507. 

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

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

  510. 	lilv_node_free(some_uri);

  511. 

  512. 	lilv_plugin_classes_free(children);

  513. 

  514. 	cleanup_uris();

  515. 	return 1;

  516. }

  517. 

  518. /*****************************************************************************/

  519. 

  520. static int

  521. test_plugin(void)

  522. {

  523. 	if (!start_bundle(MANIFEST_PREFIXES

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

  525. 			BUNDLE_PREFIXES

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

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

  528. 			LICENSE_GPL " ; "

  529. 			"lv2:optionalFeature lv2:hardRTCapable ; "

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

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

  532. 			":foo 1.6180 ; "

  533. 			":bar true ; "

  534. 			":baz false ; "

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

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

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

  538. 			"lv2:port [ "

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

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

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

  542. 			"] , [ "

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

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

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

  546. 			"] , [ "

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

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

  549. 			"  lv2:portProperty lv2:reportsLatency ; "

  550. 			"  lv2:designation lv2:latency "

  551. 			"] . \n"

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

  553. 		return 0;

  554. 

  555. 	init_uris();

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

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

  558. 	TEST_ASSERT(plug);

  559. 

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

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

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

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

  564. 

  565. 	LilvNode* rdf_type = lilv_new_uri(

  566. 		world, "http://www.w3.org/1999/02/22-rdf-syntax-ns#type");

  567. 	TEST_ASSERT(lilv_world_ask(world,

  568. 	                           lilv_plugin_get_uri(plug),

  569. 	                           rdf_type,

  570. 	                           klass_uri));

  571. 	lilv_node_free(rdf_type);

  572. 

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

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

  575. 

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

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

  578. 

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

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

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

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

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

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

  585. 

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

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

  588. 	lilv_node_free(manifest_uri_val);

  589. 

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

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

  592. 	lilv_node_free(data_uri_val);

  593. 

  594. 	free(manifest_uri);

  595. 	free(data_uri);

  596. 

  597. 	float mins[3];

  598. 	float maxs[3];

  599. 	float defs[3];

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

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

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

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

  604. 

  605. 	LilvNode* audio_class = lilv_new_uri(world,

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

  607. 	LilvNode* control_class = lilv_new_uri(world,

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

  609. 	LilvNode* in_class = lilv_new_uri(world,

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

  611. 	LilvNode* out_class = lilv_new_uri(world,

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

  613. 

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

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

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

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

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

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

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

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

  622. 

  623. 	TEST_ASSERT(lilv_plugin_has_latency(plug));

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

  625. 

  626. 	LilvNode* lv2_latency = lilv_new_uri(world,

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

  628. 	const LilvPort* latency_port = lilv_plugin_get_port_by_designation(

  629. 		plug, out_class, lv2_latency);

  630. 	lilv_node_free(lv2_latency);

  631. 

  632. 	TEST_ASSERT(latency_port);

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

  634. 

  635. 	LilvNode* rt_feature = lilv_new_uri(world,

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

  637. 	LilvNode* event_feature = lilv_new_uri(world,

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

  639. 	LilvNode* pretend_feature = lilv_new_uri(world,

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

  641. 

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

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

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

  645. 

  646. 	lilv_node_free(rt_feature);

  647. 	lilv_node_free(event_feature);

  648. 	lilv_node_free(pretend_feature);

  649. 

  650. 	LilvNodes* supported = lilv_plugin_get_supported_features(plug);

  651. 	LilvNodes* required = lilv_plugin_get_required_features(plug);

  652. 	LilvNodes* optional = lilv_plugin_get_optional_features(plug);

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

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

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

  656. 	lilv_nodes_free(supported);

  657. 	lilv_nodes_free(required);

  658. 	lilv_nodes_free(optional);

  659. 

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

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

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

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

  664. 	lilv_node_free(foo_p);

  665. 	lilv_nodes_free(foos);

  666. 

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

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

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

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

  671. 	lilv_node_free(bar_p);

  672. 	lilv_nodes_free(bars);

  673. 

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

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

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

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

  678. 	lilv_node_free(baz_p);

  679. 	lilv_nodes_free(bazs);

  680. 

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

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

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

  684. 	LilvNode*  blank = lilv_nodes_get_first(blanks);

  685. 	TEST_ASSERT(lilv_node_is_blank(blank));

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

  687. 	char*       blank_tok = lilv_node_get_turtle_token(blank);

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

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

  690. 	free(blank_tok);

  691. 	lilv_node_free(blank_p);

  692. 	lilv_nodes_free(blanks);

  693. 

  694. 	LilvNode* author_name = lilv_plugin_get_author_name(plug);

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

  696. 	lilv_node_free(author_name);

  697. 

  698. 	LilvNode* author_email = lilv_plugin_get_author_email(plug);

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

  700. 	lilv_node_free(author_email);

  701. 

  702. 	LilvNode* author_homepage = lilv_plugin_get_author_homepage(plug);

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

  704. 	lilv_node_free(author_homepage);

  705. 

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

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

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

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

  710. 	LilvNode* thing_name = lilv_nodes_get_first(thing_names);

  711. 	TEST_ASSERT(thing_name);

  712. 	TEST_ASSERT(lilv_node_is_string(thing_name));

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

  714. 	LilvNode* thing_name2 = lilv_world_get(world, thing_uri, name_p, NULL);

  715. 	TEST_ASSERT(lilv_node_equals(thing_name, thing_name2));

  716. 

  717. 	LilvUIs* uis = lilv_plugin_get_uis(plug);

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

  719. 	lilv_uis_free(uis);

  720. 

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

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

  723. 	LilvNodes* extdatas = lilv_plugin_get_extension_data(plug);

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

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

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

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

  728. 	lilv_node_free(noextdata);

  729. 	lilv_node_free(extdata);

  730. 	lilv_nodes_free(extdatas);

  731. 

  732. 	lilv_nodes_free(thing_names);

  733. 	lilv_node_free(thing_uri);

  734. 	lilv_node_free(thing_name2);

  735. 	lilv_node_free(name_p);

  736. 	lilv_node_free(control_class);

  737. 	lilv_node_free(audio_class);

  738. 	lilv_node_free(in_class);

  739. 	lilv_node_free(out_class);

  740. 	cleanup_uris();

  741. 	return 1;

  742. }

  743. 

  744. /*****************************************************************************/

  745. 

  746. static int

  747. test_port(void)

  748. {

  749. 	if (!start_bundle(MANIFEST_PREFIXES

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

  751. 			BUNDLE_PREFIXES PREFIX_LV2EV

  752. 			":plug a lv2:Plugin ; "

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

  754. 			LICENSE_GPL " ; "

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

  756. 			"lv2:port [ "

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

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

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

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

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

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

  763.      		"  lv2:portProperty lv2:integer ; "

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

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

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

  767. 			"] , [\n"

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

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

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

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

  772.      		"  atom:supports <http://example.org/atomEvent> "

  773. 			"] ."))

  774. 		return 0;

  775. 

  776. 	init_uris();

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

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

  779. 	TEST_ASSERT(plug);

  780. 

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

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

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

  784. 	lilv_node_free(psym);

  785. 	TEST_ASSERT(p != NULL);

  786. 	TEST_ASSERT(p2 != NULL);

  787. 	TEST_ASSERT(p == p2);

  788. 

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

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

  791. 	TEST_ASSERT(p3 == NULL);

  792. 	lilv_node_free(nopsym);

  793. 

  794. 	LilvNode* audio_class = lilv_new_uri(world,

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

  796. 	LilvNode* control_class = lilv_new_uri(world,

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

  798. 	LilvNode* in_class = lilv_new_uri(world,

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

  800. 

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

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

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

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

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

  806. 

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

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

  809. 	lilv_nodes_free(port_properties);

  810. 

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

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

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

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

  815. 	lilv_node_free(name);

  816. 

  817. 	// Exact language match

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

  819. 	name = lilv_port_get_name(plug, p);

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

  821. 	lilv_node_free(name);

  822. 

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

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

  825. 	name = lilv_port_get_name(plug, p);

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

  827. 	lilv_node_free(name);

  828. 

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

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

  831. 	name = lilv_port_get_name(plug, p);

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

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

  834. 	lilv_node_free(name);

  835. 

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

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

  838. 	name = lilv_port_get_name(plug, p);

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

  840. 	lilv_node_free(name);

  841. 

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

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

  844. 	name = lilv_port_get_name(plug, p);

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

  846. 	lilv_node_free(name);

  847. 

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

  849. 

  850. 	// Language tagged value with no untranslated values

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

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

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

  854. 	                    "comment"));

  855. 	LilvNode* comment = lilv_port_get(plug, p, rdfs_comment);

  856. 	TEST_ASSERT(!strcmp(lilv_node_as_string(comment), "comment"));

  857. 	lilv_node_free(comment);

  858. 	lilv_nodes_free(comments);

  859. 

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

  861. 

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

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

  864. 	                    "commentaires"));

  865. 	lilv_nodes_free(comments);

  866. 

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

  868. 

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

  870. 	TEST_ASSERT(!comments);

  871. 	lilv_nodes_free(comments);

  872. 

  873. 	lilv_node_free(rdfs_comment);

  874. 

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

  876. 

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

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

  879. 

  880. 	LilvIter* sp_iter = lilv_scale_points_begin(points);

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

  882. 	TEST_ASSERT(sp0);

  883. 	sp_iter = lilv_scale_points_next(points, sp_iter);

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

  885. 	TEST_ASSERT(sp1);

  886. 

  887. 	TEST_ASSERT(

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

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

  890. 		 &&

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

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

  893. 		||

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

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

  896. 		 &&

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

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

  899. 

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

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

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

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

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

  905. 

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

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

  908. 	TEST_ASSERT(def);

  909. 	TEST_ASSERT(min);

  910. 	TEST_ASSERT(max);

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

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

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

  914. 

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

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

  917. 

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

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

  920. 

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

  922. 

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

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

  925. 	LilvNode* atom_event = lilv_new_uri(world, "http://example.org/atomEvent");

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

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

  928. 	TEST_ASSERT(lilv_port_supports_event(plug, ep, atom_event));

  929. 

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

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

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

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

  934. 	                    "store"));

  935. 	lilv_nodes_free(names);

  936. 

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

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

  939. 

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

  941. 

  942. 	lilv_world_set_option(world, LILV_OPTION_FILTER_LANG, false_val);

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

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

  945. 	lilv_nodes_free(names);

  946. 	lilv_world_set_option(world, LILV_OPTION_FILTER_LANG, true_val);

  947. 

  948. 	lilv_node_free(false_val);

  949. 	lilv_node_free(true_val);

  950. 

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

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

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

  954. 	                    "Event Input"));

  955. 	lilv_nodes_free(names);

  956. 	lilv_node_free(name_p);

  957. 

  958. 	lilv_node_free(integer_prop);

  959. 	lilv_node_free(toggled_prop);

  960. 	lilv_node_free(event_type);

  961. 	lilv_node_free(event_type_2);

  962. 	lilv_node_free(atom_event);

  963. 

  964. 	lilv_node_free(min);

  965. 	lilv_node_free(max);

  966. 	lilv_node_free(def);

  967. 

  968. 	lilv_node_free(homepage_p);

  969. 	lilv_nodes_free(homepages);

  970. 

  971. 	lilv_scale_points_free(points);

  972. 	lilv_node_free(control_class);

  973. 	lilv_node_free(audio_class);

  974. 	lilv_node_free(in_class);

  975. 	cleanup_uris();

  976. 	return 1;

  977. }

  978. 

  979. /*****************************************************************************/

  980. 

  981. static unsigned

  982. ui_supported(const char* container_type_uri,

  983.              const char* ui_type_uri)

  984. {

  985. 	return !strcmp(container_type_uri, ui_type_uri);

  986. }

  987. 

  988. static int

  989. test_ui(void)

  990. {

  991. 	if (!start_bundle(MANIFEST_PREFIXES

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

  993. 			BUNDLE_PREFIXES PREFIX_LV2UI

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

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

  996. 			LICENSE_GPL " ; "

  997. 			"lv2:optionalFeature lv2:hardRTCapable ; "

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

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

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

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

  1002. 			"lv2:port [ "

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

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

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

  1006. 			"] , [ "

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

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

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

  1010. 			"] , [ "

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

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

  1013. 			"  lv2:portProperty lv2:reportsLatency "

  1014. 			"] .\n"

  1015. 			":ui a lv2ui:GtkUI ; "

  1016. 			"  lv2ui:requiredFeature lv2ui:makeResident ; "

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

  1018. 			"  lv2ui:optionalFeature lv2ui:ext_presets . "

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

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

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

  1022. 		return 0;

  1023. 

  1024. 	init_uris();

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

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

  1027. 	TEST_ASSERT(plug);

  1028. 

  1029. 	LilvUIs* uis = lilv_plugin_get_uis(plug);

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

  1031. 

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

  1033. 	TEST_ASSERT(ui0);

  1034. 

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

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

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

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

  1039. 

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

  1041. 	TEST_ASSERT(ui0 == ui0_2);

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

  1043. 

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

  1045. 	TEST_ASSERT(ui2 != ui0);

  1046. 

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

  1048. 	TEST_ASSERT(ui3 != ui0);

  1049. 

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

  1051. 	TEST_ASSERT(noui == NULL);

  1052. 

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

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

  1055. 

  1056. 	LilvNode* ui_class_uri = lilv_new_uri(world,

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

  1058. 

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

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

  1061. 

  1062. 	const LilvNode* ui_type = NULL;

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

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

  1065. 

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

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

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

  1069. 

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

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

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

  1073. 

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

  1075. 

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

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

  1078. 

  1079. 	free(ui_binary_uri_str);

  1080. 	lilv_node_free(ui_class_uri);

  1081. 	lilv_node_free(ui_uri);

  1082. 	lilv_node_free(ui2_uri);

  1083. 	lilv_node_free(ui3_uri);

  1084. 	lilv_node_free(noui_uri);

  1085. 	lilv_node_free(expected_uri);

  1086. 	lilv_uis_free(uis);

  1087. 

  1088. 	cleanup_uris();

  1089. 	return 1;

  1090. }

  1091. 

  1092. /*****************************************************************************/

  1093. 

  1094. uint32_t atom_Float = 0;

  1095. float    in         = 1.0;

  1096. float    out        = 42.0;

  1097. 

  1098. static const void*

  1099. get_port_value(const char* port_symbol,

  1100.                void*       user_data,

  1101.                uint32_t*   size,

  1102.                uint32_t*   type)

  1103. {

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

  1105. 		*size = sizeof(float);

  1106. 		*type = atom_Float;

  1107. 		return &in;

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

  1109. 		*size = sizeof(float);

  1110. 		*type = atom_Float;

  1111. 		return &out;

  1112. 	} else {

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

  1114. 		        port_symbol);

  1115. 		*size = *type = 0;

  1116. 		return NULL;

  1117. 	}

  1118. }

  1119. 

  1120. static void

  1121. set_port_value(const char*     port_symbol,

  1122.                void*           user_data,

  1123.                const void*     value,

  1124.                uint32_t        size,

  1125.                uint32_t        type)

  1126. {

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

  1128. 		in = *(float*)value;

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

  1130. 		out = *(float*)value;

  1131. 	} else {

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

  1133. 		        port_symbol);

  1134. 	}

  1135. }

  1136. 

  1137. char** uris   = NULL;

  1138. size_t n_uris = 0;

  1139. 

  1140. static LV2_URID

  1141. map_uri(LV2_URID_Map_Handle handle,

  1142.         const char*         uri)

  1143. {

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

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

  1146. 			return i + 1;

  1147. 		}

  1148. 	}

  1149. 

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

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

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

  1153. 	return n_uris;

  1154. }

  1155. 

  1156. static const char*

  1157. unmap_uri(LV2_URID_Map_Handle handle,

  1158.           LV2_URID            urid)

  1159. {

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

  1161. 		return uris[urid - 1];

  1162. 	}

  1163. 	return NULL;

  1164. }

  1165. 

  1166. static char* temp_dir = NULL;

  1167. 

  1168. static char*

  1169. lilv_make_path(LV2_State_Make_Path_Handle handle,

  1170.                const char*                path)

  1171. {

  1172. 	return lilv_path_join(temp_dir, path);

  1173. }

  1174. 

  1175. static int

  1176. test_state(void)

  1177. {

  1178. 	init_world();

  1179. 

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

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

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

  1183. 	LilvNode*  plugin_uri = lilv_new_uri(world,

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

  1185. 	lilv_world_load_bundle(world, bundle_uri);

  1186. 	free(abs_bundle);

  1187. 	serd_node_free(&bundle);

  1188. 

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

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

  1191. 	TEST_ASSERT(plugin);

  1192. 

  1193. 	LV2_URID_Map       map           = { NULL, map_uri };

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

  1195. 	LV2_URID_Unmap     unmap         = { NULL, unmap_uri };

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

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

  1198. 

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

  1200. 

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

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

  1203. 	TEST_ASSERT(!nostate);

  1204. 

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

  1206. 	TEST_ASSERT(instance);

  1207. 	lilv_instance_activate(instance);

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

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

  1210. 	lilv_instance_run(instance, 1);

  1211. 	TEST_ASSERT(in == 1.0);

  1212. 	TEST_ASSERT(out == 1.0);

  1213. 

  1214. 	temp_dir = lilv_realpath("temp");

  1215. 

  1216. 	const char* file_dir = NULL;

  1217. 	char*       copy_dir = NULL;

  1218. 	char*       link_dir = NULL;

  1219. 	char*       save_dir = NULL;

  1220. 

  1221. 	// Get instance state state

  1222. 	LilvState* state = lilv_state_new_from_instance(

  1223. 		plugin, instance, &map,

  1224. 		file_dir, copy_dir, link_dir, save_dir,

  1225. 		get_port_value, world, 0, NULL);

  1226. 

  1227. 	// Get another instance state

  1228. 	LilvState* state2 = lilv_state_new_from_instance(

  1229. 		plugin, instance, &map,

  1230. 		file_dir, copy_dir, link_dir, save_dir,

  1231. 		get_port_value, world, 0, NULL);

  1232. 

  1233. 	// Ensure they are equal

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

  1235. 

  1236. 	// Check that we can't save a state with no URI

  1237. 	char* bad_state_str = lilv_state_to_string(

  1238. 		world, &map, &unmap, state, NULL, NULL);

  1239. 	TEST_ASSERT(!bad_state_str);

  1240. 

  1241. 	// Check that we can't restore the NULL string (and it doesn't crash)

  1242. 	LilvState* bad_state = lilv_state_new_from_string(world, &map, NULL);

  1243. 	TEST_ASSERT(!bad_state);

  1244. 	

  1245. 	// Save state to a string

  1246. 	char* state1_str = lilv_state_to_string(

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

  1248. 

  1249. 	// Restore from string

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

  1251. 

  1252. 	// Ensure they are equal

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

  1254. 	free(state1_str);

  1255. 

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

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

  1258. 

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

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

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

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

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

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

  1265. 

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

  1267. 

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

  1269. 	lilv_instance_run(instance, 1);

  1270. 	LilvState* state3 = lilv_state_new_from_instance(

  1271. 		plugin, instance, &map,

  1272. 		file_dir, copy_dir, link_dir, save_dir,

  1273. 		get_port_value, world, 0, NULL);

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

  1275. 

  1276. 	// Restore instance state to original state

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

  1278. 

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

  1280. 	LilvState* state4 = lilv_state_new_from_instance(

  1281. 		plugin, instance, &map,

  1282. 		file_dir, copy_dir, link_dir, save_dir,

  1283. 		get_port_value, world, 0, NULL);

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

  1285. 

  1286. 	// Save state to a directory

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

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

  1289. 	TEST_ASSERT(!ret);

  1290. 

  1291. 	// Load state from directory

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

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

  1294. 

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

  1296. 

  1297. 	// Save state with URI to a directory

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

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

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

  1301. 	TEST_ASSERT(!ret);

  1302. 

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

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

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

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

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

  1308. 	lilv_world_load_bundle(world, test_state_bundle);

  1309. 	lilv_world_load_resource(world, test_state_node);

  1310. 	serd_node_free(&state6_uri);

  1311. 	free(state6_path);

  1312. 

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

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

  1315. 	lilv_node_free(test_state_bundle);

  1316. 	lilv_node_free(test_state_node);

  1317. 

  1318. 	unsetenv("LV2_STATE_BUNDLE");

  1319. 

  1320. 	// Make directories and test files support

  1321. 	mkdir("temp", 0700);

  1322. 	file_dir = temp_dir;

  1323. 	mkdir("files", 0700);

  1324. 	copy_dir = lilv_realpath("files");

  1325. 	mkdir("links", 0700);

  1326. 	link_dir = lilv_realpath("links");

  1327. 

  1328. 	LV2_State_Make_Path make_path         = { NULL, lilv_make_path };

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

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

  1331. 

  1332. 	lilv_instance_deactivate(instance);

  1333. 	lilv_instance_free(instance);

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

  1335. 	lilv_instance_activate(instance);

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

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

  1338. 	lilv_instance_run(instance, 1);

  1339. 

  1340. 	// Get instance state state

  1341. 	LilvState* fstate = lilv_state_new_from_instance(

  1342. 		plugin, instance, &map,

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

  1344. 		get_port_value, world, 0, ffeatures);

  1345. 

  1346. 	// Get another instance state

  1347. 	LilvState* fstate2 = lilv_state_new_from_instance(

  1348. 		plugin, instance, &map,

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

  1350. 		get_port_value, world, 0, ffeatures);

  1351. 

  1352. 	// Should be identical

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

  1354. 

  1355. 	// Run, writing more to rec file

  1356. 	lilv_instance_run(instance, 2);

  1357. 

  1358. 	// Get yet another instance state

  1359. 	LilvState* fstate3 = lilv_state_new_from_instance(

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

  1361. 		get_port_value, world, 0, ffeatures);

  1362. 

  1363. 	// Should be different

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

  1365. 

  1366. 	// Save state to a directory

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

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

  1369. 	TEST_ASSERT(!ret);

  1370. 

  1371. 	// Load state from directory

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

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

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

  1375. 

  1376. 	// Restore instance state to loaded state

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

  1378. 

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

  1380. 	LilvState* fstate5 = lilv_state_new_from_instance(

  1381. 		plugin, instance, &map,

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

  1383. 		get_port_value, world, 0, ffeatures);

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

  1385. 

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

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

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

  1389. 	TEST_ASSERT(!ret);

  1390. 

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

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

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

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

  1395. 

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

  1397. 	lilv_instance_run(instance, 3);

  1398. 

  1399. 	// Take a new snapshot

  1400. 	LilvState* fstate7 = lilv_state_new_from_instance(

  1401. 		plugin, instance, &map,

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

  1403. 		get_port_value, world, 0, ffeatures);

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

  1405. 

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

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

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

  1409. 	TEST_ASSERT(!ret);

  1410. 

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

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

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

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

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

  1416. 

  1417. 	lilv_instance_deactivate(instance);

  1418. 	lilv_instance_free(instance);

  1419. 

  1420. 	lilv_node_free(num);

  1421. 

  1422. 	lilv_state_free(state);

  1423. 	lilv_state_free(from_str);

  1424. 	lilv_state_free(state2);

  1425. 	lilv_state_free(state3);

  1426. 	lilv_state_free(state4);

  1427. 	lilv_state_free(state5);

  1428. 	lilv_state_free(state6);

  1429. 	lilv_state_free(fstate);

  1430. 	lilv_state_free(fstate2);

  1431. 	lilv_state_free(fstate3);

  1432. 	lilv_state_free(fstate4);

  1433. 	lilv_state_free(fstate5);

  1434. 	lilv_state_free(fstate6);

  1435. 	lilv_state_free(fstate7);

  1436. 	lilv_state_free(fstate72);

  1437. 

  1438. 	// Free URI map

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

  1440. 		free(uris[i]);

  1441. 	}

  1442. 	free(uris);

  1443. 	n_uris = 0;

  1444. 

  1445. 	lilv_node_free(plugin_uri);

  1446. 	lilv_node_free(bundle_uri);

  1447. 	free(link_dir);

  1448. 	free(copy_dir);

  1449. 	free(temp_dir);

  1450. 

  1451. 	cleanup_uris();

  1452. 	return 1;

  1453. }

  1454. 

  1455. /*****************************************************************************/

  1456. 

  1457. static int

  1458. test_bad_port_symbol(void)

  1459. {

  1460. 	if (!start_bundle(MANIFEST_PREFIXES

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

  1462. 			BUNDLE_PREFIXES PREFIX_LV2EV

  1463. 			":plug a lv2:Plugin ; "

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

  1465. 			LICENSE_GPL " ; "

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

  1467. 			"lv2:port [ "

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

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

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

  1471. 			"] ."))

  1472. 		return 0;

  1473. 

  1474. 	init_uris();

  1475. 

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

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

  1478. 

  1479. 	uint32_t n_ports = lilv_plugin_get_num_ports(plug);

  1480. 	TEST_ASSERT(n_ports == 0);

  1481. 

  1482. 	cleanup_uris();

  1483. 	return 1;

  1484. }

  1485. 

  1486. /*****************************************************************************/

  1487. 

  1488. static int

  1489. test_bad_port_index(void)

  1490. {

  1491. 	if (!start_bundle(MANIFEST_PREFIXES

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

  1493. 			BUNDLE_PREFIXES PREFIX_LV2EV

  1494. 			":plug a lv2:Plugin ; "

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

  1496. 			LICENSE_GPL " ; "

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

  1498. 			"lv2:port [ "

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

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

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

  1502. 			"] ."))

  1503. 		return 0;

  1504. 

  1505. 	init_uris();

  1506. 

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

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

  1509. 

  1510. 	uint32_t n_ports = lilv_plugin_get_num_ports(plug);

  1511. 	TEST_ASSERT(n_ports == 0);

  1512. 

  1513. 	cleanup_uris();

  1514. 	return 1;

  1515. }

  1516. 

  1517. /*****************************************************************************/

  1518. 

  1519. static int

  1520. test_string(void)

  1521. {

  1522. 	char* s = NULL;

  1523. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1541. 

  1542. #ifndef _WIN32

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

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

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

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

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

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

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

  1550. 	free(home_foo);

  1551. 	unsetenv("LILV_TEST_1");

  1552. #endif

  1553. 

  1554. 	return 1;

  1555. }

  1556. 

  1557. /*****************************************************************************/

  1558. 

  1559. /* add tests here */

  1560. static struct TestCase tests[] = {

  1561. 	TEST_CASE(utils),

  1562. 	TEST_CASE(value),

  1563. 	TEST_CASE(verify),

  1564. 	TEST_CASE(no_verify),

  1565. 	TEST_CASE(discovery),

  1566. 	TEST_CASE(lv2_path),

  1567. 	TEST_CASE(classes),

  1568. 	TEST_CASE(plugin),

  1569. 	TEST_CASE(port),

  1570. 	TEST_CASE(ui),

  1571. 	TEST_CASE(bad_port_symbol),

  1572. 	TEST_CASE(bad_port_index),

  1573. 	TEST_CASE(bad_port_index),

  1574. 	TEST_CASE(string),

  1575. 	TEST_CASE(state),

  1576. 	{ NULL, NULL }

  1577. };

  1578. 

  1579. static void

  1580. run_tests(void)

  1581. {

  1582. 	int i;

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

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

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

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

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

  1588. 			error_count++;

  1589. 			test_count++;

  1590. 		}

  1591. 		unload_bundle();

  1592. 		cleanup();

  1593. 	}

  1594. }

  1595. 

  1596. int

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

  1598. {

  1599. 	if (argc != 1) {

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

  1601. 		return 0;

  1602. 	}

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

  1604. 	init_tests();

  1605. 	run_tests();

  1606. 	cleanup();

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

  1608. 	return error_count ? 1 : 0;

  1609. }