| … | … | @@ -33,6 +33,7 @@ |
| 33 | 33 | #include <opencog/atoms/atom_types/atom_types.h> |
| 34 | 34 | #include <opencog/atoms/value/FloatValue.h> |
| 35 | 35 | #include <opencog/atoms/value/LinkValue.h> |
| 36 | #include <opencog/atoms/value/VoidValue.h> |
| 36 | 37 | #include <opencog/atomspace/AtomSpace.h> |
| 37 | 38 | #include <opencog/persist/rocks-types/atom_types.h> |
| 38 | 39 | |
| … | … | @@ -97,12 +98,12 @@ void BasicDeleteUTest::test_duplicates(void) |
| 97 | 98 | { |
| 98 | 99 | logger().debug("BEGIN TEST: %s", __FUNCTION__); |
| 99 | 100 | |
| 100 | | AtomSpace* as = new AtomSpace(); |
| 101 | AtomSpacePtr as = createAtomSpace(); |
| 101 | 102 | |
| 102 | 103 | Handle hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 103 | 104 | StorageNodePtr store = StorageNodeCast(hsn); |
| 104 | 105 | |
| 105 | | store->open(); |
| 106 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 106 | 107 | TS_ASSERT(store->connected()) |
| 107 | 108 | |
| 108 | 109 | // Clear out left-over junk, just in case. |
| … | … | @@ -116,25 +117,25 @@ void BasicDeleteUTest::test_duplicates(void) |
| 116 | 117 | store->store_atom(li); |
| 117 | 118 | store->barrier(); |
| 118 | 119 | |
| 119 | | // Verify the atomspace size |
| 120 | | TS_ASSERT_EQUALS(as->get_size(), 4); |
| 120 | // Verify the atomspace size (+1 for *-open-*) |
| 121 | TS_ASSERT_EQUALS(as->get_size(), 5); |
| 121 | 122 | |
| 122 | 123 | // Remove the link. Since the link has duplicate atoms |
| 123 | 124 | // in it, this can cause trouble, depending on how the |
| 124 | 125 | // incoming set is managed. |
| 125 | | store->remove_atom(as, li); |
| 126 | | TS_ASSERT_EQUALS(as->get_size(), 4); |
| 126 | store->remove_atom(as.get(), li); |
| 127 | TS_ASSERT_EQUALS(as->get_size(), 5); |
| 127 | 128 | store->close(); |
| 128 | 129 | as->extract_atom(li); |
| 129 | | TS_ASSERT_EQUALS(as->get_size(), 3); |
| 130 | | store->open(); |
| 131 | | store->load_atomspace(); |
| 132 | | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*) |
| 133 | 130 | TS_ASSERT_EQUALS(as->get_size(), 4); |
| 131 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 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); |
| 134 | 135 | |
| 135 | 136 | store->erase(); |
| 136 | 137 | store->close(); |
| 137 | | delete as; |
| 138 | as = nullptr; |
| 138 | 139 | |
| 139 | 140 | logger().debug("END TEST: %s", __FUNCTION__); |
| 140 | 141 | } |
| … | … | @@ -145,12 +146,12 @@ void BasicDeleteUTest::test_recursive(void) |
| 145 | 146 | { |
| 146 | 147 | logger().debug("BEGIN TEST: %s", __FUNCTION__); |
| 147 | 148 | |
| 148 | | AtomSpace* as = new AtomSpace(); |
| 149 | AtomSpacePtr as = createAtomSpace(); |
| 149 | 150 | |
| 150 | 151 | Handle hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 151 | 152 | StorageNodePtr store = StorageNodeCast(hsn); |
| 152 | 153 | |
| 153 | | store->open(); |
| 154 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 154 | 155 | TS_ASSERT(store->connected()) |
| 155 | 156 | |
| 156 | 157 | // Clear out left-over junk, just in case. |
| … | … | @@ -171,12 +172,12 @@ void BasicDeleteUTest::test_recursive(void) |
| 171 | 172 | for (const Handle& h : hset) |
| 172 | 173 | printf("Atomspace contains: %s\n", h->to_short_string().c_str()); |
| 173 | 174 | |
| 174 | | // Verify the atomspace size |
| 175 | | TS_ASSERT_EQUALS(as->get_size(), 5); |
| 175 | // Verify the atomspace size (+1 for *-open-*) |
| 176 | TS_ASSERT_EQUALS(as->get_size(), 6); |
| 176 | 177 | |
| 177 | 178 | // Remove (Concept "a"). Since this appears twice, recursion |
| 178 | 179 | // will hit it twice, in strange ways, and maybe crash. |
| 179 | | store->remove_atom(as, ha, true); |
| 180 | store->remove_atom(as.get(), ha, true); |
| 180 | 181 | |
| 181 | 182 | printf("Post-delete atomspace size=%lu\n", as->get_size()); |
| 182 | 183 | hset.clear(); |
| … | … | @@ -186,10 +187,10 @@ void BasicDeleteUTest::test_recursive(void) |
| 186 | 187 | |
| 187 | 188 | store->close(); |
| 188 | 189 | as->extract_atom(ha, true); |
| 189 | | store->open(); |
| 190 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 190 | 191 | store->load_atomspace(); |
| 191 | | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*) |
| 192 | | TS_ASSERT_EQUALS(as->get_size(), 3); |
| 192 | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*), +1 for *-open-* |
| 193 | TS_ASSERT_EQUALS(as->get_size(), 4); |
| 193 | 194 | |
| 194 | 195 | // -------------------------------------- |
| 195 | 196 | // Do it again, but with a different order. |
| … | … | @@ -200,18 +201,18 @@ void BasicDeleteUTest::test_recursive(void) |
| 200 | 201 | store->store_atom(lj); |
| 201 | 202 | store->barrier(); |
| 202 | 203 | store->close(); |
| 203 | | store->open(); |
| 204 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 204 | 205 | store->load_atomspace(); |
| 205 | | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*) |
| 206 | | TS_ASSERT_EQUALS(as->get_size(), 6); |
| 206 | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*), +1 for *-open-* |
| 207 | TS_ASSERT_EQUALS(as->get_size(), 7); |
| 207 | 208 | |
| 208 | | store->remove_atom(as, ha, true); |
| 209 | store->remove_atom(as.get(), ha, true); |
| 209 | 210 | store->close(); |
| 210 | 211 | as->extract_atom(ha, true); |
| 211 | | store->open(); |
| 212 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 212 | 213 | store->load_atomspace(); |
| 213 | | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*) |
| 214 | | TS_ASSERT_EQUALS(as->get_size(), 3); |
| 214 | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*), +1 for *-open-* |
| 215 | TS_ASSERT_EQUALS(as->get_size(), 4); |
| 215 | 216 | |
| 216 | 217 | // -------------------------------------- |
| 217 | 218 | // Do it again, but with a complex order. |
| … | … | @@ -222,18 +223,18 @@ void BasicDeleteUTest::test_recursive(void) |
| 222 | 223 | store->store_atom(lj); |
| 223 | 224 | store->barrier(); |
| 224 | 225 | store->close(); |
| 225 | | store->open(); |
| 226 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 226 | 227 | store->load_atomspace(); |
| 227 | | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*) |
| 228 | | TS_ASSERT_EQUALS(as->get_size(), 6); |
| 228 | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*), +1 for *-open-* |
| 229 | TS_ASSERT_EQUALS(as->get_size(), 7); |
| 229 | 230 | |
| 230 | | store->remove_atom(as, ha, true); |
| 231 | store->remove_atom(as.get(), ha, true); |
| 231 | 232 | store->close(); |
| 232 | 233 | as->extract_atom(ha, true); |
| 233 | | store->open(); |
| 234 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 234 | 235 | store->load_atomspace(); |
| 235 | | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*) |
| 236 | | TS_ASSERT_EQUALS(as->get_size(), 3); |
| 236 | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*), +1 for *-open-* |
| 237 | TS_ASSERT_EQUALS(as->get_size(), 4); |
| 237 | 238 | |
| 238 | 239 | // -------------------------------------- |
| 239 | 240 | // Do it again, but more deeply. |
| … | … | @@ -245,23 +246,23 @@ void BasicDeleteUTest::test_recursive(void) |
| 245 | 246 | store->store_atom(lk); |
| 246 | 247 | store->barrier(); |
| 247 | 248 | store->close(); |
| 248 | | store->open(); |
| 249 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 249 | 250 | store->load_atomspace(); |
| 250 | | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*) |
| 251 | | TS_ASSERT_EQUALS(as->get_size(), 7); |
| 251 | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*), +1 for *-open-* |
| 252 | TS_ASSERT_EQUALS(as->get_size(), 8); |
| 252 | 253 | |
| 253 | | store->remove_atom(as, ha, true); |
| 254 | store->remove_atom(as.get(), ha, true); |
| 254 | 255 | store->close(); |
| 255 | 256 | as->extract_atom(ha, true); |
| 256 | | store->open(); |
| 257 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 257 | 258 | store->load_atomspace(); |
| 258 | | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*) |
| 259 | | TS_ASSERT_EQUALS(as->get_size(), 3); |
| 259 | // +1 for *-IsKeyFlag-* (no TVs set, so no *-TruthValueKey-*), +1 for *-open-* |
| 260 | TS_ASSERT_EQUALS(as->get_size(), 4); |
| 260 | 261 | |
| 261 | 262 | // -------------------------------------- |
| 262 | 263 | store->erase(); |
| 263 | 264 | store->close(); |
| 264 | | delete as; |
| 265 | as = nullptr; |
| 265 | 266 | |
| 266 | 267 | logger().debug("END TEST: %s", __FUNCTION__); |
| 267 | 268 | } |
| … | … | @@ -273,12 +274,12 @@ void BasicDeleteUTest::test_key_deletion(void) |
| 273 | 274 | logger().debug("BEGIN TEST: %s", __FUNCTION__); |
| 274 | 275 | |
| 275 | 276 | // Create an Atom with some keys on it. |
| 276 | | AtomSpace* as = new AtomSpace(); |
| 277 | AtomSpacePtr as = createAtomSpace(); |
| 277 | 278 | |
| 278 | 279 | Handle hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 279 | 280 | StorageNodePtr store = StorageNodeCast(hsn); |
| 280 | 281 | |
| 281 | | store->open(); |
| 282 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 282 | 283 | TS_ASSERT(store->connected()) |
| 283 | 284 | |
| 284 | 285 | // Clear out left-over junk, just in case. |
| … | … | @@ -297,8 +298,8 @@ void BasicDeleteUTest::test_key_deletion(void) |
| 297 | 298 | store->store_atom(ha); |
| 298 | 299 | store->barrier(); |
| 299 | 300 | |
| 300 | | // Verify the atomspace size (+1 for *-IsKeyFlag-*) |
| 301 | | TS_ASSERT_EQUALS(as->get_size(), 6); |
| 301 | // Verify the atomspace size (+1 for *-IsKeyFlag-*, +1 for *-open-*) |
| 302 | TS_ASSERT_EQUALS(as->get_size(), 7); |
| 302 | 303 | |
| 303 | 304 | // Verify that there are three keys (getKeys() does NOT include *-IsKeyFlag-*) |
| 304 | 305 | HandleSet hs = ha->getKeys(); |
| … | … | @@ -309,17 +310,17 @@ void BasicDeleteUTest::test_key_deletion(void) |
| 309 | 310 | // Remove one of the keys. But neither the AtomSpace, nor |
| 310 | 311 | // MonoStorage allow this, and it stays both in the AtomSpace, |
| 311 | 312 | // and in storage. |
| 312 | | store->remove_atom(as, kb); |
| 313 | store->remove_atom(as.get(), kb); |
| 313 | 314 | as->extract_atom(kb); |
| 314 | | // +1 for *-IsKeyFlag-* |
| 315 | | TS_ASSERT_EQUALS(as->get_size(), 6); |
| 315 | // +1 for *-IsKeyFlag-*, +1 for *-open-* |
| 316 | TS_ASSERT_EQUALS(as->get_size(), 7); |
| 316 | 317 | |
| 317 | 318 | // Verify the key was NOT deleted by loading only PredicateNodes. |
| 318 | | delete as; |
| 319 | | as = new AtomSpace(); |
| 319 | as = nullptr; |
| 320 | as = createAtomSpace(); |
| 320 | 321 | hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 321 | 322 | store = StorageNodeCast(hsn); |
| 322 | | store->open(); |
| 323 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 323 | 324 | store->fetch_all_atoms_of_type(PREDICATE_NODE); |
| 324 | 325 | |
| 325 | 326 | // key-b should still be there. |
| … | … | @@ -333,28 +334,28 @@ void BasicDeleteUTest::test_key_deletion(void) |
| 333 | 334 | // without the close(). |
| 334 | 335 | |
| 335 | 336 | // We are done. |
| 336 | | delete as; |
| 337 | as = nullptr; |
| 337 | 338 | |
| 338 | 339 | // ------------------------------------------------------- |
| 339 | 340 | // Start again, with a fresh connection. |
| 340 | 341 | // Verify that keys that are in use cannot be deleted. |
| 341 | 342 | |
| 342 | | as = new AtomSpace(); |
| 343 | as = createAtomSpace(); |
| 343 | 344 | |
| 344 | 345 | hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 345 | 346 | store = StorageNodeCast(hsn); |
| 346 | 347 | |
| 347 | | store->open(); |
| 348 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 348 | 349 | TS_ASSERT(store->connected()) |
| 349 | 350 | |
| 350 | | // We expect 7 atoms: +2 for *-TruthValueKey-* and *-IsKeyFlag-* |
| 351 | // We expect 8 atoms: +2 for *-TruthValueKey-* and *-IsKeyFlag-*, +1 for *-open-* |
| 351 | 352 | // (Concept "a"), (Predicate "key-a"), (Predicate "key-b"), (Predicate "key-c"), |
| 352 | 353 | // (MonoStorageNode ...), (Predicate "*-TruthValueKey-*"), |
| 353 | | // (Predicate "*-IsKeyFlag-*") |
| 354 | // (Predicate "*-IsKeyFlag-*"), (Predicate "*-open-*") |
| 354 | 355 | // Note: key-b removal doesn't work in Mono storage - it's still present |
| 355 | 356 | printf("Loading the atomspace ...\n"); |
| 356 | 357 | store->load_atomspace(); |
| 357 | | TS_ASSERT_EQUALS(as->get_size(), 7); |
| 358 | TS_ASSERT_EQUALS(as->get_size(), 8); |
| 358 | 359 | |
| 359 | 360 | // Cannot delete a key that is in use. So all 3 keys remain. |
| 360 | 361 | ha = as->add_node(CONCEPT_NODE, "a"); |
| … | … | @@ -365,7 +366,7 @@ void BasicDeleteUTest::test_key_deletion(void) |
| 365 | 366 | |
| 366 | 367 | store->erase(); |
| 367 | 368 | store->close(); |
| 368 | | delete as; |
| 369 | as = nullptr; |
| 369 | 370 | |
| 370 | 371 | logger().debug("END TEST: %s", __FUNCTION__); |
| 371 | 372 | } |
| … | … | @@ -379,12 +380,12 @@ void BasicDeleteUTest::test_key_corruption(void) |
| 379 | 380 | logger().debug("BEGIN TEST: %s", __FUNCTION__); |
| 380 | 381 | |
| 381 | 382 | // Create an Atom with some keys on it. |
| 382 | | AtomSpace* as = new AtomSpace(); |
| 383 | AtomSpacePtr as = createAtomSpace(); |
| 383 | 384 | |
| 384 | 385 | Handle hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 385 | 386 | StorageNodePtr store = StorageNodeCast(hsn); |
| 386 | 387 | |
| 387 | | store->open(); |
| 388 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 388 | 389 | TS_ASSERT(store->connected()) |
| 389 | 390 | |
| 390 | 391 | // Clear out left-over junk, just in case. |
| … | … | @@ -400,14 +401,14 @@ void BasicDeleteUTest::test_key_corruption(void) |
| 400 | 401 | store->store_atom(hb); |
| 401 | 402 | store->barrier(); |
| 402 | 403 | |
| 403 | | // Verify the atomspace size (+1 for *-IsKeyFlag-*) |
| 404 | | TS_ASSERT_EQUALS(as->get_size(), 5); |
| 404 | // Verify the atomspace size (+1 for *-IsKeyFlag-*, +1 for *-open-*) |
| 405 | TS_ASSERT_EQUALS(as->get_size(), 6); |
| 405 | 406 | |
| 406 | 407 | // Remove the value |
| 407 | | store->remove_atom(as, hx); |
| 408 | store->remove_atom(as.get(), hx); |
| 408 | 409 | as->extract_atom(hx); |
| 409 | | // +1 for *-IsKeyFlag-* |
| 410 | | TS_ASSERT_EQUALS(as->get_size(), 4); |
| 410 | // +1 for *-IsKeyFlag-*, +1 for *-open-* |
| 411 | TS_ASSERT_EQUALS(as->get_size(), 5); |
| 411 | 412 | |
| 412 | 413 | // FYI, we should call store->close() at this point, but we |
| 413 | 414 | // don't, because ... most users forget to do this too. |
| … | … | @@ -415,21 +416,21 @@ void BasicDeleteUTest::test_key_corruption(void) |
| 415 | 416 | // without the close(). |
| 416 | 417 | |
| 417 | 418 | // We are done. |
| 418 | | delete as; |
| 419 | as = nullptr; |
| 419 | 420 | |
| 420 | 421 | // ------------------------------------------------------- |
| 421 | 422 | // Start again, with a fresh connection. |
| 422 | 423 | // Verify that the delete key is really deleted. |
| 423 | 424 | |
| 424 | | as = new AtomSpace(); |
| 425 | as = createAtomSpace(); |
| 425 | 426 | |
| 426 | 427 | hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 427 | 428 | store = StorageNodeCast(hsn); |
| 428 | 429 | |
| 429 | | store->open(); |
| 430 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 430 | 431 | TS_ASSERT(store->connected()) |
| 431 | 432 | |
| 432 | | // We expect 6 keys: +1 for truth-value key, +1 for *-IsKeyFlag-*. |
| 433 | // We expect 7 keys: +1 for truth-value key, +1 for *-IsKeyFlag-*, +1 for *-open-*. |
| 433 | 434 | // That's because the (Concept "x") sitting in the Value |
| 434 | 435 | // was never actually deleted; thus it is restored. |
| 435 | 436 | printf("Loading the atomspace ...\n"); |
| … | … | @@ -440,9 +441,9 @@ void BasicDeleteUTest::test_key_corruption(void) |
| 440 | 441 | for (const Handle& h: hset) |
| 441 | 442 | printf("Atomspace contains h=%s\n", h->to_short_string().c_str()); |
| 442 | 443 | |
| 443 | | // Size stays at 6 because (Concept "x") cannot be deleted. |
| 444 | | // +2 for *-TruthValueKey-* and *-IsKeyFlag-* |
| 445 | | TS_ASSERT_EQUALS(as->get_size(), 6); |
| 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); |
| 446 | 447 | |
| 447 | 448 | hb = as->add_node(CONCEPT_NODE, "b"); |
| 448 | 449 | hx = as->add_node(CONCEPT_NODE, "x"); |
| … | … | @@ -455,41 +456,41 @@ void BasicDeleteUTest::test_key_corruption(void) |
| 455 | 456 | store->store_atom(hb); |
| 456 | 457 | store->barrier(); |
| 457 | 458 | |
| 458 | | // +2 for *-TruthValueKey-* and *-IsKeyFlag-* |
| 459 | | TS_ASSERT_EQUALS(as->get_size(), 8); |
| 459 | // +2 for *-TruthValueKey-* and *-IsKeyFlag-*, +1 for *-open-* |
| 460 | TS_ASSERT_EQUALS(as->get_size(), 9); |
| 460 | 461 | |
| 461 | 462 | // Remove the value .. again |
| 462 | | store->remove_atom(as, hx); |
| 463 | store->remove_atom(as.get(), hx); |
| 463 | 464 | as->extract_atom(hx); |
| 464 | | // +2 for *-TruthValueKey-* and *-IsKeyFlag-* |
| 465 | | TS_ASSERT_EQUALS(as->get_size(), 7); |
| 465 | // +2 for *-TruthValueKey-* and *-IsKeyFlag-*, +1 for *-open-* |
| 466 | TS_ASSERT_EQUALS(as->get_size(), 8); |
| 466 | 467 | store->close(); |
| 467 | | store->open(); |
| 468 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 468 | 469 | store->load_atomspace(); |
| 469 | | // Size stays at 8 because (Concept "x") cannot be deleted. |
| 470 | | // +2 for *-TruthValueKey-* and *-IsKeyFlag-* |
| 471 | | TS_ASSERT_EQUALS(as->get_size(), 8); |
| 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); |
| 472 | 473 | |
| 473 | 474 | // We are done. |
| 474 | 475 | store->close(); |
| 475 | | delete as; |
| 476 | as = nullptr; |
| 476 | 477 | |
| 477 | 478 | // ------------------------------------------------------- |
| 478 | 479 | // Start again, with a fresh connection. |
| 479 | 480 | // Verify that the delete key is really deleted. |
| 480 | 481 | |
| 481 | | as = new AtomSpace(); |
| 482 | as = createAtomSpace(); |
| 482 | 483 | |
| 483 | 484 | hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 484 | 485 | store = StorageNodeCast(hsn); |
| 485 | 486 | |
| 486 | | store->open(); |
| 487 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 487 | 488 | TS_ASSERT(store->connected()) |
| 488 | 489 | |
| 489 | | // We expect 8 atoms: +2 for *-TruthValueKey-* and *-IsKeyFlag-* |
| 490 | // We expect 9 atoms: +2 for *-TruthValueKey-* and *-IsKeyFlag-*, +1 for *-open-* |
| 490 | 491 | printf("Loading the atomspace ...\n"); |
| 491 | 492 | store->load_atomspace(); |
| 492 | | TS_ASSERT_EQUALS(as->get_size(), 8); |
| 493 | TS_ASSERT_EQUALS(as->get_size(), 9); |
| 493 | 494 | |
| 494 | 495 | // Verify that there are two keys (getKeys() does NOT include internal markers) |
| 495 | 496 | hb = as->add_node(CONCEPT_NODE, "b"); |
| … | … | @@ -504,7 +505,7 @@ void BasicDeleteUTest::test_key_corruption(void) |
| 504 | 505 | |
| 505 | 506 | store->erase(); |
| 506 | 507 | store->close(); |
| 507 | | delete as; |
| 508 | as = nullptr; |
| 508 | 509 | |
| 509 | 510 | logger().debug("END TEST: %s", __FUNCTION__); |
| 510 | 511 | } |