1c9c974 · opencog-atomspace-rocks

Changed files (6) +63 -61

tests/persist/monospace/MonoBasicDeleteUTest.cxxtest +31 -32

…	…	@@ -130,8 +130,8 @@ void BasicDeleteUTest::test_duplicates(void)
130	130	TS_ASSERT_EQUALS(as->get_size(), 4);
131	131	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
132	132	store->load_atomspace();
133		// +1 for -IsKeyFlag- (no TVs set, so no -TruthValueKey-), +1 for -open-
134		TS_ASSERT_EQUALS(as->get_size(), 5);
	133	// +1 for -IsKeyFlag-, +1 for -open-
	134	TS_ASSERT_EQUALS(as->get_size(), 4);
135	135
136	136	store->erase();
137	137	store->close();
…	…	@@ -189,8 +189,8 @@ void BasicDeleteUTest::test_recursive(void)
189	189	as->extract_atom(ha, true);
190	190	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
191	191	store->load_atomspace();
192		// +1 for -IsKeyFlag- (no TVs set, so no -TruthValueKey-), +1 for -open-
193		TS_ASSERT_EQUALS(as->get_size(), 4);
	192	// +1 for -IsKeyFlag-, +1 for -open-
	193	TS_ASSERT_EQUALS(as->get_size(), 3);
194	194
195	195	// --------------------------------------
196	196	// Do it again, but with a different order.
…	…	@@ -203,16 +203,16 @@ void BasicDeleteUTest::test_recursive(void)
203	203	store->close();
204	204	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
205	205	store->load_atomspace();
206		// +1 for -IsKeyFlag- (no TVs set, so no -TruthValueKey-), +1 for -open-
207		TS_ASSERT_EQUALS(as->get_size(), 7);
	206	// +1 for -IsKeyFlag-, +1 for -open-
	207	TS_ASSERT_EQUALS(as->get_size(), 6);
208	208
209	209	store->remove_atom(as.get(), ha, true);
210	210	store->close();
211	211	as->extract_atom(ha, true);
212	212	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
213	213	store->load_atomspace();
214		// +1 for -IsKeyFlag- (no TVs set, so no -TruthValueKey-), +1 for -open-
215		TS_ASSERT_EQUALS(as->get_size(), 4);
	214	// +1 for -IsKeyFlag-, +1 for -open-
	215	TS_ASSERT_EQUALS(as->get_size(), 3);
216	216
217	217	// --------------------------------------
218	218	// Do it again, but with a complex order.
…	…	@@ -225,16 +225,16 @@ void BasicDeleteUTest::test_recursive(void)
225	225	store->close();
226	226	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
227	227	store->load_atomspace();
228		// +1 for -IsKeyFlag- (no TVs set, so no -TruthValueKey-), +1 for -open-
229		TS_ASSERT_EQUALS(as->get_size(), 7);
	228	// +1 for -IsKeyFlag-, +1 for -open-
	229	TS_ASSERT_EQUALS(as->get_size(), 6);
230	230
231	231	store->remove_atom(as.get(), ha, true);
232	232	store->close();
233	233	as->extract_atom(ha, true);
234	234	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
235	235	store->load_atomspace();
236		// +1 for -IsKeyFlag- (no TVs set, so no -TruthValueKey-), +1 for -open-
237		TS_ASSERT_EQUALS(as->get_size(), 4);
	236	// +1 for -IsKeyFlag-, +1 for -open-
	237	TS_ASSERT_EQUALS(as->get_size(), 3);
238	238
239	239	// --------------------------------------
240	240	// Do it again, but more deeply.
…	…	@@ -248,16 +248,16 @@ void BasicDeleteUTest::test_recursive(void)
248	248	store->close();
249	249	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
250	250	store->load_atomspace();
251		// +1 for -IsKeyFlag- (no TVs set, so no -TruthValueKey-), +1 for -open-
252		TS_ASSERT_EQUALS(as->get_size(), 8);
	251	// +1 for -IsKeyFlag-, +1 for -open-
	252	TS_ASSERT_EQUALS(as->get_size(), 7);
253	253
254	254	store->remove_atom(as.get(), ha, true);
255	255	store->close();
256	256	as->extract_atom(ha, true);
257	257	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
258	258	store->load_atomspace();
259		// +1 for -IsKeyFlag- (no TVs set, so no -TruthValueKey-), +1 for -open-
260		TS_ASSERT_EQUALS(as->get_size(), 4);
	259	// +1 for -IsKeyFlag-, +1 for -open-
	260	TS_ASSERT_EQUALS(as->get_size(), 3);
261	261
262	262	// --------------------------------------
263	263	store->erase();
…	…	@@ -348,14 +348,13 @@ void BasicDeleteUTest::test_key_deletion(void)
348	348	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
349	349	TS_ASSERT(store->connected())
350	350
351		// We expect 8 atoms: +2 for -TruthValueKey- and -IsKeyFlag-, +1 for -open-
	351	// We expect 7 atoms: +1 for -IsKeyFlag-, +1 for -open-
352	352	// (Concept "a"), (Predicate "key-a"), (Predicate "key-b"), (Predicate "key-c"),
353		// (MonoStorageNode ...), (Predicate "-TruthValueKey-"),
354		// (Predicate "-IsKeyFlag-"), (Predicate "-open-")
	353	// (MonoStorageNode ...), (Predicate "-IsKeyFlag-"), (Predicate "-open-")
355	354	// Note: key-b removal doesn't work in Mono storage - it's still present
356	355	printf("Loading the atomspace ...\n");
357	356	store->load_atomspace();
358		TS_ASSERT_EQUALS(as->get_size(), 8);
	357	TS_ASSERT_EQUALS(as->get_size(), 7);
359	358
360	359	// Cannot delete a key that is in use. So all 3 keys remain.
361	360	ha = as->add_node(CONCEPT_NODE, "a");
…	…	@@ -441,9 +440,9 @@ void BasicDeleteUTest::test_key_corruption(void)
441	440	for (const Handle& h: hset)
442	441	printf("Atomspace contains h=%s\n", h->to_short_string().c_str());
443	442
444		// Size stays at 7 because (Concept "x") cannot be deleted.
445		// +2 for -TruthValueKey- and -IsKeyFlag-, +1 for -open-
446		TS_ASSERT_EQUALS(as->get_size(), 7);
	443	// Size stays at 6 because (Concept "x") cannot be deleted.
	444	// +1 for -IsKeyFlag-, +1 for -open-
	445	TS_ASSERT_EQUALS(as->get_size(), 6);
447	446
448	447	hb = as->add_node(CONCEPT_NODE, "b");
449	448	hx = as->add_node(CONCEPT_NODE, "x");
…	…	@@ -456,20 +455,20 @@ void BasicDeleteUTest::test_key_corruption(void)
456	455	store->store_atom(hb);
457	456	store->barrier();
458	457
459		// +2 for -TruthValueKey- and -IsKeyFlag-, +1 for -open-
460		TS_ASSERT_EQUALS(as->get_size(), 9);
	458	// +1 for -IsKeyFlag-, +1 for -open-
	459	TS_ASSERT_EQUALS(as->get_size(), 8);
461	460
462	461	// Remove the value .. again
463	462	store->remove_atom(as.get(), hx);
464	463	as->extract_atom(hx);
465		// +2 for -TruthValueKey- and -IsKeyFlag-, +1 for -open-
466		TS_ASSERT_EQUALS(as->get_size(), 8);
	464	// +1 for -IsKeyFlag-, +1 for -open-
	465	TS_ASSERT_EQUALS(as->get_size(), 7);
467	466	store->close();
468	467	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
469	468	store->load_atomspace();
470		// Size stays at 9 because (Concept "x") cannot be deleted.
471		// +2 for -TruthValueKey- and -IsKeyFlag-, +1 for -open-
472		TS_ASSERT_EQUALS(as->get_size(), 9);
	469	// Size stays at 8 because (Concept "x") cannot be deleted.
	470	// +1 for -IsKeyFlag-, +1 for -open-
	471	TS_ASSERT_EQUALS(as->get_size(), 8);
473	472
474	473	// We are done.
475	474	store->close();
…	…	@@ -487,10 +486,10 @@ void BasicDeleteUTest::test_key_corruption(void)
487	486	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
488	487	TS_ASSERT(store->connected())
489	488
490		// We expect 9 atoms: +2 for -TruthValueKey- and -IsKeyFlag-, +1 for -open-
	489	// We expect 8 atoms: +1 for -IsKeyFlag-, +1 for -open-
491	490	printf("Loading the atomspace ...\n");
492	491	store->load_atomspace();
493		TS_ASSERT_EQUALS(as->get_size(), 9);
	492	TS_ASSERT_EQUALS(as->get_size(), 8);
494	493
495	494	// Verify that there are two keys (getKeys() does NOT include internal markers)
496	495	hb = as->add_node(CONCEPT_NODE, "b");

tests/persist/monospace/MonoFetchUTest.cxxtest +4 -2

…	…	@@ -211,11 +211,13 @@ void MonoFetchUTest::test_stuff(void)
211	211	printf("Expecting %s\n", etv->to_string().c_str());
212	212	printf("Got %s\n", tv->to_string().c_str());
213	213
214		// BBB should have been clobbered.
	214	// BBB should retain its original value (TVs persist in storage).
215	215	eval->eval(R"((fetch-atom (Concept "BBB")))");
216	216	eval->eval("(barrier)");
217	217	tv = eval->eval_v(R"((cog-value (Concept "BBB") tvkey))");
218		TS_ASSERT(tv == nullptr);
	218	etv = createFloatValue(std::vector<double>({0.2, 0.22}));
	219	TS_ASSERT(tv != nullptr);
	220	TS_ASSERT((tv) == (etv));
219	221
220	222	eval->eval("(cog-close)");
221	223	logger().debug("END TEST: %s", __FUNCTION__);

tests/persist/monospace/MonoMultiDeleteUTest.cxxtest +2 -3

…	…	@@ -199,10 +199,9 @@ void MultiDeleteUTest::test_add_delete(void)
199	199	store->load_atomspace();
200	200	printf("Final AtomSpace size=%lu\n", as->get_size());
201	201
202		// Size should be 19: the 18 from before plus that annoying
203		// (Predicate "-TruthValueKey-")
	202	// Size should be 18: the 18 from before, plus predicates:
204	203	// +1 for (Predicate "-open-"), +1 for (Predicate "-close-")
205		size_t expected_size = 5 + n_threads + 6;
	204	size_t expected_size = 5 + n_threads + 5;
206	205	if (as->get_size() != expected_size)
207	206	printf("Error: Bad size! AtomSpace contents =\n%s\n",
208	207	as->to_string().c_str());

tests/persist/rocks/BasicDeleteUTest.cxxtest +18 -18

…	…	@@ -133,7 +133,7 @@ void BasicDeleteUTest::test_duplicates(void)
133	133	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
134	134	store->load_atomspace();
135	135	// +1 for -IsKeyFlag-, +1 for -open-, +1 for -close-
136		TS_ASSERT_EQUALS(as->get_size(), 6);
	136	TS_ASSERT_EQUALS(as->get_size(), 5);
137	137
138	138	store->erase();
139	139	store->setValue(as->add_node(PREDICATE_NODE, "-close-"), createVoidValue());
…	…	@@ -192,7 +192,7 @@ void BasicDeleteUTest::test_recursive(void)
192	192	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
193	193	store->load_atomspace();
194	194	// +1 for -IsKeyFlag-, +1 for -open-, +1 for -close-
195		TS_ASSERT_EQUALS(as->get_size(), 5);
	195	TS_ASSERT_EQUALS(as->get_size(), 4);
196	196
197	197	// --------------------------------------
198	198	// Do it again, but with a different order.
…	…	@@ -206,7 +206,7 @@ void BasicDeleteUTest::test_recursive(void)
206	206	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
207	207	store->load_atomspace();
208	208	// +1 for -IsKeyFlag-, +1 for -open-, +1 for -close-
209		TS_ASSERT_EQUALS(as->get_size(), 8);
	209	TS_ASSERT_EQUALS(as->get_size(), 7);
210	210
211	211	store->remove_atom(as.get(), ha, true);
212	212	store->setValue(as->add_node(PREDICATE_NODE, "-close-"), createVoidValue());
…	…	@@ -214,7 +214,7 @@ void BasicDeleteUTest::test_recursive(void)
214	214	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
215	215	store->load_atomspace();
216	216	// +1 for -IsKeyFlag-, +1 for -open-, +1 for -close-
217		TS_ASSERT_EQUALS(as->get_size(), 5);
	217	TS_ASSERT_EQUALS(as->get_size(), 4);
218	218
219	219	// --------------------------------------
220	220	// Do it again, but with a complex order.
…	…	@@ -228,7 +228,7 @@ void BasicDeleteUTest::test_recursive(void)
228	228	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
229	229	store->load_atomspace();
230	230	// +1 for -IsKeyFlag-, +1 for -open-, +1 for -close-
231		TS_ASSERT_EQUALS(as->get_size(), 8);
	231	TS_ASSERT_EQUALS(as->get_size(), 7);
232	232
233	233	store->remove_atom(as.get(), ha, true);
234	234	store->setValue(as->add_node(PREDICATE_NODE, "-close-"), createVoidValue());
…	…	@@ -236,7 +236,7 @@ void BasicDeleteUTest::test_recursive(void)
236	236	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
237	237	store->load_atomspace();
238	238	// +1 for -IsKeyFlag-, +1 for -open-, +1 for -close-
239		TS_ASSERT_EQUALS(as->get_size(), 5);
	239	TS_ASSERT_EQUALS(as->get_size(), 4);
240	240
241	241	// --------------------------------------
242	242	// Do it again, but more deeply.
…	…	@@ -251,7 +251,7 @@ void BasicDeleteUTest::test_recursive(void)
251	251	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
252	252	store->load_atomspace();
253	253	// +1 for -IsKeyFlag-, +1 for -open-, +1 for -close-
254		TS_ASSERT_EQUALS(as->get_size(), 9);
	254	TS_ASSERT_EQUALS(as->get_size(), 8);
255	255
256	256	store->remove_atom(as.get(), ha, true);
257	257	store->setValue(as->add_node(PREDICATE_NODE, "-close-"), createVoidValue());
…	…	@@ -259,7 +259,7 @@ void BasicDeleteUTest::test_recursive(void)
259	259	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
260	260	store->load_atomspace();
261	261	// +1 for -IsKeyFlag-, +1 for -open-, +1 for -close-
262		TS_ASSERT_EQUALS(as->get_size(), 5);
	262	TS_ASSERT_EQUALS(as->get_size(), 4);
263	263
264	264	// --------------------------------------
265	265	store->erase();
…	…	@@ -348,10 +348,10 @@ void BasicDeleteUTest::test_key_deletion(void)
348	348	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
349	349	TS_ASSERT(store->connected())
350	350
351		// We expect 8 atoms (+1 for -IsKeyFlag-, +1 for -open-)
	351	// We expect 7 atoms (+1 for -IsKeyFlag-, +1 for -open-)
352	352	printf("Loading the atomspace ...\n");
353	353	store->load_atomspace();
354		TS_ASSERT_EQUALS(as->get_size(), 8);
	354	TS_ASSERT_EQUALS(as->get_size(), 7);
355	355	printf("AtomSpace contents=\n%s\n", as->to_string().c_str());
356	356
357	357	// Verify that there are only three keys
…	…	@@ -443,9 +443,9 @@ void BasicDeleteUTest::test_key_corruption(void)
443	443	for (const Handle& h: hset)
444	444	printf("Atomspace contains h=%s\n", h->to_short_string().c_str());
445	445
446		// Size is 7 because (Concept "x") cannot be deleted.
	446	// Size is 6 because (Concept "x") cannot be deleted.
447	447	// +1 for -IsKeyFlag-, +1 for -open-
448		TS_ASSERT_EQUALS(as->get_size(), 7);
	448	TS_ASSERT_EQUALS(as->get_size(), 6);
449	449
450	450	hb = as->add_node(CONCEPT_NODE, "b");
451	451	hx = as->add_node(CONCEPT_NODE, "x");
…	…	@@ -459,19 +459,19 @@ void BasicDeleteUTest::test_key_corruption(void)
459	459	store->barrier();
460	460
461	461	// +1 for -IsKeyFlag-, +1 for -open-
462		TS_ASSERT_EQUALS(as->get_size(), 9);
	462	TS_ASSERT_EQUALS(as->get_size(), 8);
463	463
464	464	// Remove the value .. again
465	465	store->remove_atom(as.get(), hx);
466	466	as->extract_atom(hx);
467	467	// +1 for -IsKeyFlag-, +1 for -open-
468		TS_ASSERT_EQUALS(as->get_size(), 8);
	468	TS_ASSERT_EQUALS(as->get_size(), 7);
469	469	store->setValue(as->add_node(PREDICATE_NODE, "-close-"), createVoidValue());
470	470	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
471	471	store->load_atomspace();
472		// Size is 10 because (Concept "x") cannot be deleted.
	472	// Size is 9 because (Concept "x") cannot be deleted.
473	473	// +1 for -IsKeyFlag-, +1 for -open-, +1 for -close-
474		TS_ASSERT_EQUALS(as->get_size(), 10);
	474	TS_ASSERT_EQUALS(as->get_size(), 9);
475	475
476	476	// We are done.
477	477	store->setValue(as->add_node(PREDICATE_NODE, "-close-"), createVoidValue());
…	…	@@ -489,10 +489,10 @@ void BasicDeleteUTest::test_key_corruption(void)
489	489	store->setValue(as->add_node(PREDICATE_NODE, "-open-"), createVoidValue());
490	490	TS_ASSERT(store->connected())
491	491
492		// We expect 9 atoms (+1 for -IsKeyFlag-, +1 for -open-)
	492	// We expect 8 atoms (+1 for -IsKeyFlag-, +1 for -open-)
493	493	printf("Loading the atomspace ...\n");
494	494	store->load_atomspace();
495		TS_ASSERT_EQUALS(as->get_size(), 9);
	495	TS_ASSERT_EQUALS(as->get_size(), 8);
496	496
497	497	// Verify that there are two keys
498	498	hb = as->add_node(CONCEPT_NODE, "b");

tests/persist/rocks/FetchUTest.cxxtest +4 -2

…	…	@@ -215,11 +215,13 @@ void FetchUTest::test_stuff(void)
215	215	printf("Expecting %s\n", etv->to_string().c_str());
216	216	printf("Got %s\n", tv->to_string().c_str());
217	217
218		// BBB should have been clobbered.
	218	// BBB should retain its original value (TVs persist in storage).
219	219	eval->eval(R"((fetch-atom (Concept "BBB")))");
220	220	eval->eval("(barrier)");
221	221	tv = eval->eval_v(R"((cog-value (Concept "BBB") tvkey))");
222		TS_ASSERT(tv == nullptr);
	222	etv = createFloatValue(std::vector<double>({0.2, 0.22}));
	223	TS_ASSERT(tv != nullptr);
	224	TS_ASSERT((tv) == (etv));
223	225
224	226	eval->eval("(cog-close)");
225	227	logger().debug("END TEST: %s", __FUNCTION__);

tests/persist/rocks/space-episodic-test.scm +4 -4

…	…	@@ -99,13 +99,13 @@
99	99	(count-all (cog-value (ConceptNode "foo") (Predicate "real life")))
100	100	(count-all (cog-value (ConceptNode "foo") (Predicate "repressed mem"))))
101	101
102		; 11 loaded plus one RocksStorageNode plus (Predicate "-TruthValueKey-")
103		; Plus two more: (Predicate "-store-atomspace-")
	102	; 11 loaded plus one RocksStorageNode
	103	; Plus: (Predicate "-store-atomspace-")
104	104	; and (Predicate "-load-atomspace-") and -open- and -close-
105	105	; and (Predicate "kayfabe") from test-utils.
106	106	; +1 for (Predicate "-IsKeyFlag-")
107	107
108		(test-assert "base-count" (equal? 18 (count-all)))
	108	(test-assert "base-count" (equal? 17 (count-all)))
109	109	(test-assert "space1-count" (equal? 0
110	110	(count-all (cog-value (ConceptNode "foo") (Predicate "real life")))))
111	111	(test-assert "space2-count" (equal? 0
…	…	@@ -117,7 +117,7 @@
117	117	(cog-set-value! gsn (-close-))
118	118
119	119	; +1 for (Predicate "-IsKeyFlag-")
120		(test-assert "base-count" (equal? 19 (count-all)))
	120	(test-assert "base-count" (equal? 18 (count-all)))
121	121	(test-assert "space1-count" (equal? 8
122	122	(count-all (cog-value (ConceptNode "foo") (Predicate "real life")))))
123	123	(test-assert "space2-count" (equal? 6

opencog-atomspace-rocks commits / 1c9c974

Changed files (6) +63 -61