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.
4123 Commits
16 Branches
16GB
Tree: aae1f71089
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'aae1f71089'
${ noResults }
Carla/source/modules/lilv/sord-0.16.0/src/sord_test.c

762 lines
25KB
Raw Blame History 

  1. /*

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

  3. 

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

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

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

  7. 

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

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

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

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

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

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

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

  15. */

  16. 

  17. #include <stdarg.h>

  18. #include <stdio.h>

  19. #include <stdlib.h>

  20. #include <string.h>

  21. 

  22. #include "sord/sord.h"

  23. 

  24. static const int      DIGITS        = 3;

  25. static const unsigned n_objects_per = 2;

  26. 

  27. static int n_expected_errors = 0;

  28. 

  29. typedef struct {

  30. 	SordQuad query;

  31. 	int      expected_num_results;

  32. } QueryTest;

  33. 

  34. #define USTR(s) ((const uint8_t*)(s))

  35. 

  36. static SordNode*

  37. uri(SordWorld* world, int num)

  38. {

  39. 	if (num == 0)

  40. 		return 0;

  41. 

  42. 	char  str[]   = "eg:000";

  43. 	char* uri_num = str + 3;  // First `0'

  44. 	snprintf(uri_num, DIGITS + 1, "%0*d", DIGITS, num);

  45. 	return sord_new_uri(world, (const uint8_t*)str);

  46. }

  47. 

  48. static int

  49. test_fail(const char* fmt, ...)

  50. {

  51. 	va_list args;

  52. 	va_start(args, fmt);

  53. 	fprintf(stderr, "error: ");

  54. 	vfprintf(stderr, fmt, args);

  55. 	va_end(args);

  56. 	return 1;

  57. }

  58. 

  59. static int

  60. generate(SordWorld* world,

  61.          SordModel* sord,

  62.          size_t     n_quads,

  63.          SordNode*  graph)

  64. {

  65. 	fprintf(stderr, "Generating %zu (S P *) quads with %u objects each\n",

  66. 	        n_quads, n_objects_per);

  67. 

  68. 	for (size_t i = 0; i < n_quads; ++i) {

  69. 		int num = (i * n_objects_per) + 1;

  70. 

  71. 		SordNode* ids[2 + n_objects_per];

  72. 		for (unsigned j = 0; j < 2 + n_objects_per; ++j) {

  73. 			ids[j] = uri(world, num++);

  74. 		}

  75. 

  76. 		for (unsigned j = 0; j < n_objects_per; ++j) {

  77. 			SordQuad tup = { ids[0], ids[1], ids[2 + j], graph };

  78. 			if (!sord_add(sord, tup)) {

  79. 				return test_fail("Fail: Failed to add quad\n");

  80. 			}

  81. 		}

  82. 

  83. 		for (unsigned j = 0; j < 2 + n_objects_per; ++j) {

  84. 			sord_node_free(world, ids[j]);

  85. 		}

  86. 	}

  87. 

  88. 	// Add some literals

  89. 

  90. 	// (98 4 "hello") and (98 4 "hello"^^<5>)

  91. 	SordQuad tup = { 0, 0, 0, 0 };

  92. 	tup[0] = uri(world, 98);

  93. 	tup[1] = uri(world, 4);

  94. 	tup[2] = sord_new_literal(world, 0, USTR("hello"), NULL);

  95. 	tup[3] = graph;

  96. 	sord_add(sord, tup);

  97. 	sord_node_free(world, (SordNode*)tup[2]);

  98. 	tup[2] = sord_new_literal(world, uri(world, 5), USTR("hello"), NULL);

  99. 	if (!sord_add(sord, tup)) {

  100. 		return test_fail("Failed to add typed literal\n");

  101. 	}

  102. 

  103. 	// (96 4 "hello"^^<4>) and (96 4 "hello"^^<5>)

  104. 	tup[0] = uri(world, 96);

  105. 	tup[1] = uri(world, 4);

  106. 	tup[2] = sord_new_literal(world, uri(world, 4), USTR("hello"), NULL);

  107. 	tup[3] = graph;

  108. 	sord_add(sord, tup);

  109. 	sord_node_free(world, (SordNode*)tup[2]);

  110. 	tup[2] = sord_new_literal(world, uri(world, 5), USTR("hello"), NULL);

  111. 	if (!sord_add(sord, tup)) {

  112. 		return test_fail("Failed to add typed literal\n");

  113. 	}

  114. 

  115. 	// (94 5 "hello") and (94 5 "hello"@en-gb)

  116. 	tup[0] = uri(world, 94);

  117. 	tup[1] = uri(world, 5);

  118. 	tup[2] = sord_new_literal(world, 0, USTR("hello"), NULL);

  119. 	tup[3] = graph;

  120. 	sord_add(sord, tup);

  121. 	sord_node_free(world, (SordNode*)tup[2]);

  122. 	tup[2] = sord_new_literal(world, NULL, USTR("hello"), "en-gb");

  123. 	if (!sord_add(sord, tup)) {

  124. 		return test_fail("Failed to add literal with language\n");

  125. 	}

  126. 

  127. 	// (92 6 "hello"@en-us) and (92 5 "hello"@en-gb)

  128. 	tup[0] = uri(world, 92);

  129. 	tup[1] = uri(world, 6);

  130. 	tup[2] = sord_new_literal(world, 0, USTR("hello"), "en-us");

  131. 	tup[3] = graph;

  132. 	sord_add(sord, tup);

  133. 	sord_node_free(world, (SordNode*)tup[2]);

  134. 	tup[2] = sord_new_literal(world, NULL, USTR("hello"), "en-gb");

  135. 	if (!sord_add(sord, tup)) {

  136. 		return test_fail("Failed to add literal with language\n");

  137. 	}

  138. 

  139. 	sord_node_free(world, (SordNode*)tup[0]);

  140. 	sord_node_free(world, (SordNode*)tup[2]);

  141. 	tup[0] = uri(world, 14);

  142. 	tup[2] = sord_new_literal(world, 0, USTR("bonjour"), "fr");

  143. 	sord_add(sord, tup);

  144. 	sord_node_free(world, (SordNode*)tup[2]);

  145. 	tup[2] = sord_new_literal(world, 0, USTR("salut"), "fr");

  146. 	sord_add(sord, tup);

  147. 

  148. 	// Attempt to add some duplicates

  149. 	if (sord_add(sord, tup)) {

  150. 		return test_fail("Fail: Successfully added duplicate quad\n");

  151. 	}

  152. 	if (sord_add(sord, tup)) {

  153. 		return test_fail("Fail: Successfully added duplicate quad\n");

  154. 	}

  155. 

  156. 	// Add a blank node subject

  157. 	sord_node_free(world, (SordNode*)tup[0]);

  158. 	tup[0] = sord_new_blank(world, USTR("ablank"));

  159. 	sord_add(sord, tup);

  160. 

  161. 	sord_node_free(world, (SordNode*)tup[1]);

  162. 	sord_node_free(world, (SordNode*)tup[2]);

  163. 	tup[1] = uri(world, 6);

  164. 	tup[2] = uri(world, 7);

  165. 	sord_add(sord, tup);

  166. 	sord_node_free(world, (SordNode*)tup[0]);

  167. 	sord_node_free(world, (SordNode*)tup[1]);

  168. 	sord_node_free(world, (SordNode*)tup[2]);

  169. 

  170. 	return EXIT_SUCCESS;

  171. }

  172. 

  173. #define TUP_FMT "(%6s %6s %6s)"

  174. #define TUP_FMT_ARGS(t) \

  175. 	((t)[0] ? sord_node_get_string((t)[0]) : USTR("*")), \

  176. 		((t)[1] ? sord_node_get_string((t)[1]) : USTR("*")), \

  177. 		((t)[2] ? sord_node_get_string((t)[2]) : USTR("*"))

  178. 

  179. static int

  180. test_read(SordWorld* world, SordModel* sord, SordNode* g,

  181.           const size_t n_quads)

  182. {

  183. 	int ret = EXIT_SUCCESS;

  184. 

  185. 	SordQuad id;

  186. 

  187. 	SordIter* iter = sord_begin(sord);

  188. 	if (sord_iter_get_model(iter) != sord) {

  189. 		return test_fail("Fail: Iterator has incorrect sord pointer\n");

  190. 	}

  191. 

  192. 	for (; !sord_iter_end(iter); sord_iter_next(iter))

  193. 		sord_iter_get(iter, id);

  194. 

  195. 	// Attempt to increment past end

  196. 	if (!sord_iter_next(iter)) {

  197. 		return test_fail("Fail: Successfully incremented past end\n");

  198. 	}

  199. 

  200. 	sord_iter_free(iter);

  201. 

  202. 	const uint8_t* s = USTR("hello");

  203. 	SordNode* plain_hello = sord_new_literal(world, 0, s, NULL);

  204. 	SordNode* type4_hello = sord_new_literal(world, uri(world, 4), s, NULL);

  205. 	SordNode* type5_hello = sord_new_literal(world, uri(world, 5), s, NULL);

  206. 	SordNode* gb_hello    = sord_new_literal(world, NULL, s, "en-gb");

  207. 	SordNode* us_hello    = sord_new_literal(world, NULL, s, "en-us");

  208. 

  209. #define NUM_PATTERNS 18

  210. 

  211. 	QueryTest patterns[NUM_PATTERNS] = {

  212. 		{ { 0, 0, 0 }, (int)(n_quads * n_objects_per) + 12 },

  213. 		{ { uri(world, 1), 0, 0 }, 2 },

  214. 		{ { uri(world, 9), uri(world, 9), uri(world, 9) }, 0 },

  215. 		{ { uri(world, 1), uri(world, 2), uri(world, 4) }, 1 },

  216. 		{ { uri(world, 3), uri(world, 4), uri(world, 0) }, 2 },

  217. 		{ { uri(world, 0), uri(world, 2), uri(world, 4) }, 1 },

  218. 		{ { uri(world, 0), uri(world, 0), uri(world, 4) }, 1 },

  219. 		{ { uri(world, 1), uri(world, 0), uri(world, 0) }, 2 },

  220. 		{ { uri(world, 1), uri(world, 0), uri(world, 4) }, 1 },

  221. 		{ { uri(world, 0), uri(world, 2), uri(world, 0) }, 2 },

  222. 		{ { uri(world, 98), uri(world, 4), plain_hello  }, 1 },

  223. 		{ { uri(world, 98), uri(world, 4), type5_hello  }, 1 },

  224. 		{ { uri(world, 96), uri(world, 4), type4_hello  }, 1 },

  225. 		{ { uri(world, 96), uri(world, 4), type5_hello  }, 1 },

  226. 		{ { uri(world, 94), uri(world, 5), plain_hello  }, 1 },

  227. 		{ { uri(world, 94), uri(world, 5), gb_hello     }, 1 },

  228. 		{ { uri(world, 92), uri(world, 6), gb_hello     }, 1 },

  229. 		{ { uri(world, 92), uri(world, 6), us_hello     }, 1 } };

  230. 

  231. 	SordQuad match = { uri(world, 1), uri(world, 2), uri(world, 4), g };

  232. 	if (!sord_contains(sord, match)) {

  233. 		return test_fail("Fail: No match for " TUP_FMT "\n",

  234. 		                 TUP_FMT_ARGS(match));

  235. 	}

  236. 

  237. 	SordQuad nomatch = { uri(world, 1), uri(world, 2), uri(world, 9), g };

  238. 	if (sord_contains(sord, nomatch)) {

  239. 		return test_fail("Fail: False match for " TUP_FMT "\n",

  240. 		                 TUP_FMT_ARGS(nomatch));

  241. 	}

  242. 

  243. 	if (sord_get(sord, NULL, NULL, uri(world, 3), g)) {

  244. 		return test_fail("Fail: Get *,*,3 succeeded\n");

  245. 	} else if (!sord_node_equals(

  246. 		           sord_get(sord, uri(world, 1), uri(world, 2), NULL, g),

  247. 		           uri(world, 3))) {

  248. 		return test_fail("Fail: Get 1,2,* != 3\n");

  249. 	} else if (!sord_node_equals(

  250. 		           sord_get(sord, uri(world, 1), NULL, uri(world, 3), g),

  251. 		           uri(world, 2))) {

  252. 		return test_fail("Fail: Get 1,*,3 != 2\n");

  253. 	} else if (!sord_node_equals(

  254. 		           sord_get(sord, NULL, uri(world, 2), uri(world, 3), g),

  255. 		           uri(world, 1))) {

  256. 		return test_fail("Fail: Get *,2,3 != 1\n");

  257. 	}

  258. 

  259. 	for (unsigned i = 0; i < NUM_PATTERNS; ++i) {

  260. 		QueryTest test = patterns[i];

  261. 		SordQuad  pat = { test.query[0], test.query[1], test.query[2], g };

  262. 		fprintf(stderr, "Query " TUP_FMT "... ", TUP_FMT_ARGS(pat));

  263. 

  264. 		iter = sord_find(sord, pat);

  265. 		int num_results = 0;

  266. 		for (; !sord_iter_end(iter); sord_iter_next(iter)) {

  267. 			sord_iter_get(iter, id);

  268. 			++num_results;

  269. 			if (!sord_quad_match(pat, id)) {

  270. 				sord_iter_free(iter);

  271. 				return test_fail(

  272. 					"Fail: Query result " TUP_FMT " does not match pattern\n",

  273. 					TUP_FMT_ARGS(id));

  274. 			}

  275. 		}

  276. 		sord_iter_free(iter);

  277. 		if (num_results != test.expected_num_results) {

  278. 			return test_fail("Fail: Expected %d results, got %d\n",

  279. 			                 test.expected_num_results, num_results);

  280. 		}

  281. 		fprintf(stderr, "OK (%u matches)\n", test.expected_num_results);

  282. 	}

  283. 

  284. 	// Query blank node subject

  285. 	SordQuad pat = { sord_new_blank(world, USTR("ablank")), 0, 0 };

  286. 	if (!pat[0]) {

  287. 		return test_fail("Blank node subject lost\n");

  288. 	}

  289. 	fprintf(stderr, "Query " TUP_FMT "... ", TUP_FMT_ARGS(pat));

  290. 	iter = sord_find(sord, pat);

  291. 	int num_results = 0;

  292. 	for (; !sord_iter_end(iter); sord_iter_next(iter)) {

  293. 		sord_iter_get(iter, id);

  294. 		++num_results;

  295. 		if (!sord_quad_match(pat, id)) {

  296. 			sord_iter_free(iter);

  297. 			return test_fail(

  298. 				"Fail: Query result " TUP_FMT " does not match pattern\n",

  299. 				TUP_FMT_ARGS(id));

  300. 		}

  301. 	}

  302. 	fprintf(stderr, "OK\n");

  303. 	sord_node_free(world, (SordNode*)pat[0]);

  304. 	sord_iter_free(iter);

  305. 	if (num_results != 2) {

  306. 		return test_fail("Blank node subject query failed\n");

  307. 	}

  308. 

  309. 	// Test nested queries

  310. 	fprintf(stderr, "Nested Queries... ");

  311. 	const SordNode* last_subject = 0;

  312. 	iter = sord_search(sord, NULL, NULL, NULL, NULL);

  313. 	for (; !sord_iter_end(iter); sord_iter_next(iter)) {

  314. 		sord_iter_get(iter, id);

  315. 		if (id[0] == last_subject)

  316. 			continue;

  317. 

  318. 		SordQuad  subpat          = { id[0], 0, 0 };

  319. 		SordIter* subiter         = sord_find(sord, subpat);

  320. 		uint64_t  num_sub_results = 0;

  321. 		if (sord_iter_get_node(subiter, SORD_SUBJECT) != id[0]) {

  322. 			return test_fail("Fail: Incorrect initial submatch\n");

  323. 		}

  324. 		for (; !sord_iter_end(subiter); sord_iter_next(subiter)) {

  325. 			SordQuad subid;

  326. 			sord_iter_get(subiter, subid);

  327. 			if (!sord_quad_match(subpat, subid)) {

  328. 				sord_iter_free(iter);

  329. 				sord_iter_free(subiter);

  330. 				return test_fail(

  331. 					"Fail: Nested query result does not match pattern\n");

  332. 			}

  333. 			++num_sub_results;

  334. 		}

  335. 		sord_iter_free(subiter);

  336. 		if (num_sub_results != n_objects_per) {

  337. 			return test_fail(

  338. 				"Fail: Nested query " TUP_FMT " failed"

  339. 				" (%d results, expected %d)\n",

  340. 				TUP_FMT_ARGS(subpat), num_sub_results, n_objects_per);

  341. 		}

  342. 

  343. 		uint64_t count = sord_count(sord, id[0], 0, 0, 0);

  344. 		if (count != num_sub_results) {

  345. 			return test_fail("Fail: Query " TUP_FMT " sord_count() %d"

  346. 			                 "does not match result count %d\n",

  347. 			                 TUP_FMT_ARGS(subpat), count, num_sub_results);

  348. 		}

  349. 

  350. 		last_subject = id[0];

  351. 	}

  352. 	fprintf(stderr, "OK\n\n");

  353. 	sord_iter_free(iter);

  354. 

  355. 	return ret;

  356. }

  357. 

  358. static SerdStatus

  359. unexpected_error(void* handle, const SerdError* error)

  360. {

  361. 	fprintf(stderr, "unexpected error: ");

  362. 	vfprintf(stderr, error->fmt, *error->args);

  363. 	return SERD_SUCCESS;

  364. }

  365. 

  366. static SerdStatus

  367. expected_error(void* handle, const SerdError* error)

  368. {

  369. 	fprintf(stderr, "expected error: ");

  370. 	vfprintf(stderr, error->fmt, *error->args);

  371. 	++n_expected_errors;

  372. 	return SERD_SUCCESS;

  373. }

  374. 

  375. static int

  376. finished(SordWorld* world, SordModel* sord, int status)

  377. {

  378. 	sord_free(sord);

  379. 	sord_world_free(world);

  380. 	return status;

  381. }

  382. 

  383. int

  384. main(int argc, char** argv)

  385. {

  386. 	static const size_t n_quads = 300;

  387. 

  388. 	sord_free(NULL);  // Shouldn't crash

  389. 

  390. 	SordWorld* world = sord_world_new();

  391. 

  392. 

  393. 	// Attempt to create invalid URI

  394. 	fprintf(stderr, "expected ");

  395. 	SordNode* bad_uri = sord_new_uri(world, USTR("noscheme"));

  396. 	if (bad_uri) {

  397. 		return test_fail("Successfully created invalid URI \"noscheme\"\n");

  398. 	}

  399. 	sord_node_free(world, bad_uri);

  400. 

  401. 	sord_world_set_error_sink(world, expected_error, NULL);

  402. 

  403. 	// Attempt to create invalid CURIE

  404. 	SerdNode  base   = serd_node_from_string(SERD_URI, USTR("http://example.org/"));

  405. 	SerdEnv*  env    = serd_env_new(&base);

  406. 	SerdNode  sbadns = serd_node_from_string(SERD_CURIE, USTR("badns:"));

  407. 	SordNode* badns  = sord_node_from_serd_node(world, env, &sbadns, NULL, NULL);

  408. 	if (badns) {

  409. 		return test_fail("Successfully created CURIE with bad namespace\n");

  410. 	}

  411. 	sord_node_free(world, badns);

  412. 	serd_env_free(env);

  413. 

  414. 	// Attempt to create node from garbage

  415. 	SerdNode junk = SERD_NODE_NULL;

  416. 	junk.type = (SerdType)1234;

  417. 	if (sord_node_from_serd_node(world, env, &junk, NULL, NULL)) {

  418. 		return test_fail("Successfully created node from garbage serd node\n");

  419. 	}

  420. 

  421. 	// Attempt to create NULL node

  422. 	SordNode* nil_node = sord_node_from_serd_node(

  423. 		world, NULL, &SERD_NODE_NULL, NULL, NULL);

  424. 	if (nil_node) {

  425. 		return test_fail("Successfully created NULL node\n");

  426. 	}

  427. 	sord_node_free(world, nil_node);

  428. 

  429. 	// Attempt to double-free a node

  430. 	SordNode* garbage = sord_new_uri(world, USTR("urn:garbage"));

  431. 	sord_node_free(world, garbage);

  432. 	sord_world_set_error_sink(world, expected_error, NULL);

  433. 	sord_node_free(world, garbage);

  434. 	sord_world_set_error_sink(world, unexpected_error, NULL);

  435. 	if (n_expected_errors != 2) {

  436. 		return test_fail("Successfully freed node twice\n");

  437. 	}

  438. 

  439. 	sord_world_set_error_sink(world, unexpected_error, NULL);

  440. 

  441. 	// Check node flags are set properly

  442. 	SordNode* with_newline = sord_new_literal(world, NULL, USTR("a\nb"), NULL);

  443. 	if (!(sord_node_get_flags(with_newline) & SERD_HAS_NEWLINE)) {

  444. 		return test_fail("Newline flag not set\n");

  445. 	}

  446. 	SordNode* with_quote = sord_new_literal(world, NULL, USTR("a\"b"), NULL);

  447. 	if (!(sord_node_get_flags(with_quote) & SERD_HAS_QUOTE)) {

  448. 		return test_fail("Quote flag not set\n");

  449. 	}

  450. 

  451. 	// Create with minimal indexing

  452. 	SordModel* sord = sord_new(world, SORD_SPO, false);

  453. 	generate(world, sord, n_quads, NULL);

  454. 

  455. 	if (test_read(world, sord, NULL, n_quads)) {

  456. 		sord_free(sord);

  457. 		sord_world_free(world);

  458. 		return EXIT_FAILURE;

  459. 	}

  460. 

  461. 	// Check adding tuples with NULL fields fails

  462. 	sord_world_set_error_sink(world, expected_error, NULL);

  463. 	const size_t initial_num_quads = sord_num_quads(sord);

  464. 	SordQuad tup = { 0, 0, 0, 0};

  465. 	if (sord_add(sord, tup)) {

  466. 		return test_fail("Added NULL tuple\n");

  467. 	}

  468. 	tup[0] = uri(world, 1);

  469. 	if (sord_add(sord, tup)) {

  470. 		return test_fail("Added tuple with NULL P and O\n");

  471. 	}

  472. 	tup[1] = uri(world, 2);

  473. 	if (sord_add(sord, tup)) {

  474. 		return test_fail("Added tuple with NULL O\n");

  475. 	}

  476. 

  477. 	if (sord_num_quads(sord) != initial_num_quads) {

  478. 		return test_fail("Num quads %zu != %zu\n",

  479. 		                 sord_num_quads(sord), initial_num_quads);

  480. 	}

  481. 

  482. 	// Check adding tuples with an active iterator fails

  483. 	SordIter* iter = sord_begin(sord);

  484. 	tup[2] = uri(world, 3);

  485. 	if (sord_add(sord, tup)) {

  486. 		return test_fail("Added tuple with active iterator\n");

  487. 	}

  488. 

  489. 	// Check removing tuples with several active iterator fails

  490. 	SordIter* iter2 = sord_begin(sord);

  491. 	if (!sord_erase(sord, iter)) {

  492. 		return test_fail("Erased tuple with several active iterators\n");

  493. 	}

  494. 	n_expected_errors = 0;

  495. 	sord_remove(sord, tup);

  496. 	if (n_expected_errors != 1) {

  497. 		return test_fail("Removed tuple with several active iterators\n");

  498. 	}

  499. 	sord_iter_free(iter);

  500. 	sord_iter_free(iter2);

  501. 

  502. 	sord_world_set_error_sink(world, unexpected_error, NULL);

  503. 

  504. 	// Check interning merges equivalent values

  505. 	SordNode* uri_id   = sord_new_uri(world, USTR("http://example.org"));

  506. 	SordNode* blank_id = sord_new_blank(world, USTR("testblank"));

  507. 	SordNode* lit_id   = sord_new_literal(world, uri_id, USTR("hello"), NULL);

  508. 	if (sord_node_get_type(uri_id) != SORD_URI) {

  509. 		return test_fail("URI node has incorrect type\n");

  510. 	} else if (sord_node_get_type(blank_id) != SORD_BLANK) {

  511. 		return test_fail("Blank node has incorrect type\n");

  512. 	} else if (sord_node_get_type(lit_id) != SORD_LITERAL) {

  513. 		return test_fail("Literal node has incorrect type\n");

  514. 	}

  515. 

  516. 	const size_t initial_num_nodes = sord_num_nodes(world);

  517. 

  518. 	SordNode* uri_id2   = sord_new_uri(world, USTR("http://example.org"));

  519. 	SordNode* blank_id2 = sord_new_blank(world, USTR("testblank"));

  520. 	SordNode* lit_id2   = sord_new_literal(world, uri_id, USTR("hello"), NULL);

  521. 	if (uri_id2 != uri_id || !sord_node_equals(uri_id2, uri_id)) {

  522. 		fprintf(stderr, "Fail: URI interning failed (duplicates)\n");

  523. 		return finished(world, sord, EXIT_FAILURE);

  524. 	} else if (blank_id2 != blank_id

  525. 	           || !sord_node_equals(blank_id2, blank_id)) {

  526. 		fprintf(stderr, "Fail: Blank node interning failed (duplicates)\n");

  527. 		return finished(world, sord, EXIT_FAILURE);

  528. 	} else if (lit_id2 != lit_id || !sord_node_equals(lit_id2, lit_id)) {

  529. 		fprintf(stderr, "Fail: Literal interning failed (duplicates)\n");

  530. 		return finished(world, sord, EXIT_FAILURE);

  531. 	}

  532. 

  533. 	if (sord_num_nodes(world) != initial_num_nodes) {

  534. 		return test_fail("Num nodes %zu != %zu\n",

  535. 		                 sord_num_nodes(world), initial_num_nodes);

  536. 	}

  537. 

  538. 	const uint8_t ni_hao[] = { 0xE4, 0xBD, 0xA0, 0xE5, 0xA5, 0xBD };

  539. 	SordNode*     chello   = sord_new_literal(world, NULL, ni_hao, "cmn");

  540. 

  541. 	// Test literal length

  542. 	size_t         n_bytes;

  543. 	size_t         n_chars;

  544. 	const uint8_t* str = sord_node_get_string_counted(lit_id2, &n_bytes);

  545. 	if (strcmp((const char*)str, "hello")) {

  546. 		return test_fail("Literal node corrupt\n");

  547. 	} else if (n_bytes != strlen("hello")) {

  548. 		return test_fail("ASCII literal byte count incorrect\n");

  549. 	}

  550. 

  551. 	str = sord_node_get_string_measured(lit_id2, &n_bytes, &n_chars);

  552. 	if (n_bytes != strlen("hello") || n_chars != strlen("hello")) {

  553. 		return test_fail("ASCII literal measured length incorrect\n");

  554. 	}

  555. 

  556. 	str = sord_node_get_string_measured(chello, &n_bytes, &n_chars);

  557. 	if (n_bytes != 6) {

  558. 		return test_fail("Multi-byte literal byte count incorrect\n");

  559. 	} else if (n_chars != 2) {

  560. 		return test_fail("Multi-byte literal character count incorrect\n");

  561. 	}

  562. 

  563. 	// Check interning doesn't clash non-equivalent values

  564. 	SordNode* uri_id3   = sord_new_uri(world, USTR("http://example.orgX"));

  565. 	SordNode* blank_id3 = sord_new_blank(world, USTR("testblankX"));

  566. 	SordNode* lit_id3   = sord_new_literal(world, uri_id, USTR("helloX"), NULL);

  567. 	if (uri_id3 == uri_id || sord_node_equals(uri_id3, uri_id)) {

  568. 		fprintf(stderr, "Fail: URI interning failed (clash)\n");

  569. 		return finished(world, sord, EXIT_FAILURE);

  570. 	} else if (blank_id3 == blank_id || sord_node_equals(blank_id3, blank_id)) {

  571. 		fprintf(stderr, "Fail: Blank node interning failed (clash)\n");

  572. 		return finished(world, sord, EXIT_FAILURE);

  573. 	} else if (lit_id3 == lit_id || sord_node_equals(lit_id3, lit_id)) {

  574. 		fprintf(stderr, "Fail: Literal interning failed (clash)\n");

  575. 		return finished(world, sord, EXIT_FAILURE);

  576. 	}

  577. 

  578. 	// Check literal interning

  579. 	SordNode* lit4 = sord_new_literal(world, NULL, USTR("hello"), NULL);

  580. 	SordNode* lit5 = sord_new_literal(world, uri_id2, USTR("hello"), NULL);

  581. 	SordNode* lit6 = sord_new_literal(world, NULL, USTR("hello"), "en-ca");

  582. 	if (lit4 == lit5 || sord_node_equals(lit4, lit5)

  583. 	    || lit4 == lit6 || sord_node_equals(lit4, lit6)

  584. 	    || lit5 == lit6 || sord_node_equals(lit5, lit6)) {

  585. 		fprintf(stderr, "Fail: Literal interning failed (type/lang clash)\n");

  586. 		return finished(world, sord, EXIT_FAILURE);

  587. 	}

  588. 

  589. 	// Check relative URI construction

  590. 	SordNode* reluri = sord_new_relative_uri(

  591. 		world, USTR("a/b"), USTR("http://example.org/"));

  592. 	if (strcmp((const char*)sord_node_get_string(reluri),

  593. 	           "http://example.org/a/b")) {

  594. 		fprintf(stderr, "Fail: Bad relative URI constructed: <%s>\n",

  595. 		        sord_node_get_string(reluri));

  596. 		return finished(world, sord, EXIT_FAILURE);

  597. 	}

  598. 	SordNode* reluri2 = sord_new_relative_uri(

  599. 		world, USTR("http://drobilla.net/"), USTR("http://example.org/"));

  600. 	if (strcmp((const char*)sord_node_get_string(reluri2),

  601. 	           "http://drobilla.net/")) {

  602. 		fprintf(stderr, "Fail: Bad relative URI constructed: <%s>\n",

  603. 		        sord_node_get_string(reluri));

  604. 		return finished(world, sord, EXIT_FAILURE);

  605. 	}

  606. 

  607. 	// Check comparison with NULL

  608. 	sord_node_free(world, uri_id);

  609. 	sord_node_free(world, blank_id);

  610. 	sord_node_free(world, lit_id);

  611. 	sord_node_free(world, uri_id2);

  612. 	sord_node_free(world, blank_id2);

  613. 	sord_node_free(world, lit_id2);

  614. 	sord_node_free(world, uri_id3);

  615. 	sord_node_free(world, blank_id3);

  616. 	sord_node_free(world, lit_id3);

  617. 	sord_free(sord);

  618. 

  619. 	static const char* const index_names[6] = {

  620. 		"spo", "sop", "ops", "osp", "pso", "pos"

  621. 	};

  622. 

  623. 	for (int i = 0; i < 6; ++i) {

  624. 		sord = sord_new(world, (1 << i), false);

  625. 		printf("Testing Index `%s'\n", index_names[i]);

  626. 		generate(world, sord, n_quads, 0);

  627. 		if (test_read(world, sord, 0, n_quads))

  628. 			return finished(world, sord, EXIT_FAILURE);

  629. 		sord_free(sord);

  630. 	}

  631. 

  632. 	static const char* const graph_index_names[6] = {

  633. 		"gspo", "gsop", "gops", "gosp", "gpso", "gpos"

  634. 	};

  635. 

  636. 	for (int i = 0; i < 6; ++i) {

  637. 		sord = sord_new(world, (1 << i), true);

  638. 		printf("Testing Index `%s'\n", graph_index_names[i]);

  639. 		SordNode* graph = uri(world, 42);

  640. 		generate(world, sord, n_quads, graph);

  641. 		if (test_read(world, sord, graph, n_quads))

  642. 			return finished(world, sord, EXIT_FAILURE);

  643. 		sord_free(sord);

  644. 	}

  645. 

  646. 	// Test removing

  647. 	sord = sord_new(world, SORD_SPO, true);

  648. 	tup[0] = uri(world, 1);

  649. 	tup[1] = uri(world, 2);

  650. 	tup[2] = sord_new_literal(world, 0, USTR("hello"), NULL);

  651. 	tup[3] = 0;

  652. 	sord_add(sord, tup);

  653. 	if (!sord_ask(sord, tup[0], tup[1], tup[2], tup[3])) {

  654. 		fprintf(stderr, "Failed to add tuple\n");

  655. 		return finished(world, sord, EXIT_FAILURE);

  656. 	}

  657. 	sord_node_free(world, (SordNode*)tup[2]);

  658. 	tup[2] = sord_new_literal(world, 0, USTR("hi"), NULL);

  659. 	sord_add(sord, tup);

  660. 	sord_remove(sord, tup);

  661. 	if (sord_num_quads(sord) != 1) {

  662. 		fprintf(stderr, "Remove failed (%zu quads, expected 1)\n",

  663. 		        sord_num_quads(sord));

  664. 		return finished(world, sord, EXIT_FAILURE);

  665. 	}

  666. 

  667. 	iter = sord_find(sord, tup);

  668. 	if (!sord_iter_end(iter)) {

  669. 		fprintf(stderr, "Found removed tuple\n");

  670. 		return finished(world, sord, EXIT_FAILURE);

  671. 	}

  672. 	sord_iter_free(iter);

  673. 

  674. 	// Test double remove (silent success)

  675. 	sord_remove(sord, tup);

  676. 

  677. 	// Load a couple graphs

  678. 	SordNode* graph42 = uri(world, 42);

  679. 	SordNode* graph43 = uri(world, 43);

  680. 	generate(world, sord, 1, graph42);

  681. 	generate(world, sord, 1, graph43);

  682. 

  683. 	// Remove one graph via iterator

  684. 	SerdStatus st;

  685. 	iter = sord_search(sord, NULL, NULL, NULL, graph43);

  686. 	while (!sord_iter_end(iter)) {

  687. 		if ((st = sord_erase(sord, iter))) {

  688. 			fprintf(stderr, "Remove by iterator failed (%s)\n",

  689. 			        serd_strerror(st));

  690. 			return finished(world, sord, EXIT_FAILURE);

  691. 		}

  692. 	}

  693. 	sord_iter_free(iter);

  694. 

  695. 	// Erase the first tuple (an element in the default graph)

  696. 	iter = sord_begin(sord);

  697. 	if (sord_erase(sord, iter)) {

  698. 		return test_fail("Failed to erase begin iterator on non-empty model\n");

  699. 	}

  700. 	sord_iter_free(iter);

  701. 

  702. 	// Ensure only the other graph is left

  703. 	SordQuad quad;

  704. 	SordQuad pat = { 0, 0, 0, graph42 };

  705. 	for (iter = sord_begin(sord); !sord_iter_end(iter); sord_iter_next(iter)) {

  706. 		sord_iter_get(iter, quad);

  707. 		if (!sord_quad_match(quad, pat)) {

  708. 			fprintf(stderr, "Graph removal via iteration failed\n");

  709. 			return finished(world, sord, EXIT_FAILURE);

  710. 		}

  711. 	}

  712. 	sord_iter_free(iter);

  713. 

  714. 	// Load file into two separate graphs

  715. 	sord_free(sord);

  716. 	sord = sord_new(world, SORD_SPO, true);

  717. 	env  = serd_env_new(&base);

  718. 	SordNode*   graph1 = sord_new_uri(world, USTR("http://example.org/graph1"));

  719. 	SordNode*   graph2 = sord_new_uri(world, USTR("http://example.org/graph2"));

  720. 	SerdReader* reader = sord_new_reader(sord, env, SERD_TURTLE, graph1);

  721. 	if ((st = serd_reader_read_string(reader, USTR("<s> <p> <o> .")))) {

  722. 		fprintf(stderr, "Failed to read string (%s)\n", serd_strerror(st));

  723. 		return finished(world, sord, EXIT_FAILURE);

  724. 	}

  725. 	serd_reader_free(reader);

  726. 	reader = sord_new_reader(sord, env, SERD_TURTLE, graph2);

  727. 	if ((st = serd_reader_read_string(reader, USTR("<s> <p> <o> .")))) {

  728. 		fprintf(stderr, "Failed to re-read string (%s)\n", serd_strerror(st));

  729. 		return finished(world, sord, EXIT_FAILURE);

  730. 	}

  731. 	serd_reader_free(reader);

  732. 	serd_env_free(env);

  733. 

  734. 	// Ensure we only see triple once

  735. 	size_t n_triples = 0;

  736. 	for (iter = sord_begin(sord); !sord_iter_end(iter); sord_iter_next(iter)) {

  737. 		fprintf(stderr, "%s %s %s %s\n",

  738. 		        sord_node_get_string(sord_iter_get_node(iter, SORD_SUBJECT)),

  739. 		        sord_node_get_string(sord_iter_get_node(iter, SORD_PREDICATE)),

  740. 		        sord_node_get_string(sord_iter_get_node(iter, SORD_OBJECT)),

  741. 		        sord_node_get_string(sord_iter_get_node(iter, SORD_GRAPH)));

  742. 

  743. 		++n_triples;

  744. 	}

  745. 	sord_iter_free(iter);

  746. 	if (n_triples != 1) {

  747. 		fprintf(stderr, "Found duplicate triple\n");

  748. 		return finished(world, sord, EXIT_FAILURE);

  749. 	}

  750. 

  751. 	// Test SPO iteration on an SOP indexed store

  752. 	sord_free(sord);

  753. 	sord = sord_new(world, SORD_SOP, false);

  754. 	generate(world, sord, 1, graph42);

  755. 	for (iter = sord_begin(sord); !sord_iter_end(iter); sord_iter_next(iter)) {

  756. 		++n_triples;

  757. 	}

  758. 	sord_iter_free(iter);

  759. 

  760. 	return finished(world, sord, EXIT_SUCCESS);

  761. }