| … | … | @@ -37,7 +37,7 @@ |
| 37 | 37 | #include <opencog/atoms/value/FloatValue.h> |
| 38 | 38 | #include <opencog/atoms/value/LinkValue.h> |
| 39 | 39 | #include <opencog/atoms/value/StringValue.h> |
| 40 | | #include <opencog/atoms/value/FloatValue.h> |
| 40 | #include <opencog/atoms/value/VoidValue.h> |
| 41 | 41 | |
| 42 | 42 | #include <opencog/persist/monospace/MonoStorage.h> |
| 43 | 43 | |
| … | … | @@ -105,10 +105,10 @@ void ValueSaveUTest::test_single_atom_save() |
| 105 | 105 | { |
| 106 | 106 | logger().info("BEGIN TEST: %s", __FUNCTION__); |
| 107 | 107 | |
| 108 | | AtomSpace* as = new AtomSpace(); |
| 108 | AtomSpacePtr as = createAtomSpace(); |
| 109 | 109 | Handle hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 110 | 110 | StorageNodePtr store = StorageNodeCast(hsn); |
| 111 | | store->open(); |
| 111 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 112 | 112 | TS_ASSERT(store->connected()) |
| 113 | 113 | |
| 114 | 114 | Handle key = as->add_node(PREDICATE_NODE, "some pred key"); |
| … | … | @@ -154,8 +154,6 @@ void ValueSaveUTest::test_single_atom_save() |
| 154 | 154 | store->store_atom(atom); |
| 155 | 155 | store->barrier(); |
| 156 | 156 | |
| 157 | | delete as; |
| 158 | | |
| 159 | 157 | logger().info("END TEST: %s", __FUNCTION__); |
| 160 | 158 | } |
| 161 | 159 | |
| … | … | @@ -172,10 +170,10 @@ void ValueSaveUTest::check_one(ValuePtr pap, bool fetchkey) |
| 172 | 170 | // ------ |
| 173 | 171 | // First, save the value |
| 174 | 172 | |
| 175 | | AtomSpace* as = new AtomSpace(); |
| 173 | AtomSpacePtr as = createAtomSpace(); |
| 176 | 174 | Handle hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 177 | 175 | StorageNodePtr store = StorageNodeCast(hsn); |
| 178 | | store->open(); |
| 176 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 179 | 177 | TS_ASSERT(store->connected()) |
| 180 | 178 | |
| 181 | 179 | Handle key = store->fetch_atom(bkey); |
| … | … | @@ -190,15 +188,12 @@ void ValueSaveUTest::check_one(ValuePtr pap, bool fetchkey) |
| 190 | 188 | printf ("Stored atom %s\n", atom->to_string().c_str()); |
| 191 | 189 | printf ("Stored vals %s\n", atom->valuesToString().c_str()); |
| 192 | 190 | |
| 193 | | delete as; |
| 194 | | |
| 195 | 191 | // --------------------------------- |
| 196 | 192 | // Now, fetch the value and compare. |
| 197 | | |
| 198 | | as = new AtomSpace(); |
| 193 | as = createAtomSpace(); |
| 199 | 194 | hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 200 | 195 | store = StorageNodeCast(hsn); |
| 201 | | store->open(); |
| 196 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 202 | 197 | TS_ASSERT(store->connected()) |
| 203 | 198 | |
| 204 | 199 | // Storage uses a different code path if the key is not yet |
| … | … | @@ -212,18 +207,16 @@ void ValueSaveUTest::check_one(ValuePtr pap, bool fetchkey) |
| 212 | 207 | |
| 213 | 208 | printf("Expecting %s\n", pap->to_string().c_str()); |
| 214 | 209 | TS_ASSERT(*pap == *fap); |
| 215 | | |
| 216 | | delete as; |
| 217 | 210 | } |
| 218 | 211 | |
| 219 | 212 | void ValueSaveUTest::test_save_restore(bool fkey) |
| 220 | 213 | { |
| 221 | 214 | logger().info("BEGIN TEST: %s", __FUNCTION__); |
| 222 | 215 | |
| 223 | | AtomSpace* as = new AtomSpace(); |
| 216 | AtomSpacePtr as = createAtomSpace(); |
| 224 | 217 | Handle hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 225 | 218 | StorageNodePtr store = StorageNodeCast(hsn); |
| 226 | | store->open(); |
| 219 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 227 | 220 | TS_ASSERT(store->connected()) |
| 228 | 221 | |
| 229 | 222 | Handle key = as->add_node(PREDICATE_NODE, "some pred key"); |
| … | … | @@ -261,8 +254,12 @@ void ValueSaveUTest::test_save_restore(bool fkey) |
| 261 | 254 | |
| 262 | 255 | check_one(pvl2, fkey); |
| 263 | 256 | |
| 257 | // Clean up the database |
| 258 | as = createAtomSpace(); |
| 259 | hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 260 | store = StorageNodeCast(hsn); |
| 261 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 264 | 262 | store->erase(); |
| 265 | | delete as; |
| 266 | 263 | |
| 267 | 264 | logger().info("END TEST: %s", __FUNCTION__); |
| 268 | 265 | } |
| … | … | @@ -276,10 +273,10 @@ void ValueSaveUTest::test_load_by_type() |
| 276 | 273 | { |
| 277 | 274 | logger().info("BEGIN TEST: %s", __FUNCTION__); |
| 278 | 275 | |
| 279 | | AtomSpace* as = new AtomSpace(); |
| 276 | AtomSpacePtr as = createAtomSpace(); |
| 280 | 277 | Handle hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 281 | 278 | StorageNodePtr store = StorageNodeCast(hsn); |
| 282 | | store->open(); |
| 279 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 283 | 280 | TS_ASSERT(store->connected()) |
| 284 | 281 | |
| 285 | 282 | // Clear out left-over junk, just in case. |
| … | … | @@ -332,15 +329,13 @@ void ValueSaveUTest::test_load_by_type() |
| 332 | 329 | store->store_atom(al); |
| 333 | 330 | store->store_atom(av); |
| 334 | 331 | store->barrier(); |
| 335 | | delete as; |
| 336 | 332 | |
| 337 | 333 | // -------------------- |
| 338 | 334 | // Start it up again. |
| 339 | | |
| 340 | | as = new AtomSpace(); |
| 335 | as = createAtomSpace(); |
| 341 | 336 | hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 342 | 337 | store = StorageNodeCast(hsn); |
| 343 | | store->open(); |
| 338 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 344 | 339 | TS_ASSERT(store->connected()) |
| 345 | 340 | |
| 346 | 341 | // -------------------- |
| … | … | @@ -348,12 +343,12 @@ void ValueSaveUTest::test_load_by_type() |
| 348 | 343 | store->fetch_all_atoms_of_type(CONCEPT_NODE); |
| 349 | 344 | store->barrier(); |
| 350 | 345 | |
| 351 | | // Eight: 4 ConceptNodes, PredicateNode "*-TruthValueKey-*", |
| 346 | // Nine: 4 ConceptNodes, PredicateNode "*-TruthValueKey-*", |
| 352 | 347 | // PredicateNode "*-IsKeyFlag-*", PredicateNode "some pred key", |
| 353 | | // and the MonoStorageNode -- the preds show up when the |
| 354 | | // attached values are fetched. |
| 348 | // PredicateNode "*-open-*", and the MonoStorageNode -- the preds |
| 349 | // show up when the attached values are fetched. |
| 355 | 350 | printf ("fetched %lu atoms\n", as->get_size()); |
| 356 | | TSM_ASSERT("Wrong number of Atoms fetched!", as->get_size() == 8); |
| 351 | TSM_ASSERT("Wrong number of Atoms fetched!", as->get_size() == 9); |
| 357 | 352 | |
| 358 | 353 | Handle gkey = as->add_node(PREDICATE_NODE, "some pred key"); |
| 359 | 354 | Handle gaf = as->add_node(CONCEPT_NODE, "float node"); |
| … | … | @@ -388,9 +383,6 @@ void ValueSaveUTest::test_load_by_type() |
| 388 | 383 | TS_ASSERT(*gpl == *pvl); |
| 389 | 384 | TS_ASSERT(*gpv == *pvv); |
| 390 | 385 | |
| 391 | | // -------------------- |
| 392 | | delete as; |
| 393 | | |
| 394 | 386 | logger().info("END TEST: %s", __FUNCTION__); |
| 395 | 387 | } |
| 396 | 388 | |
| … | … | @@ -405,10 +397,10 @@ void ValueSaveUTest::test_link_by_type() |
| 405 | 397 | { |
| 406 | 398 | logger().info("BEGIN TEST: %s", __FUNCTION__); |
| 407 | 399 | |
| 408 | | AtomSpace* as = new AtomSpace(); |
| 400 | AtomSpacePtr as = createAtomSpace(); |
| 409 | 401 | Handle hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 410 | 402 | StorageNodePtr store = StorageNodeCast(hsn); |
| 411 | | store->open(); |
| 403 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 412 | 404 | TS_ASSERT(store->connected()) |
| 413 | 405 | |
| 414 | 406 | Handle key = as->add_node(PREDICATE_NODE, "some pred key"); |
| … | … | @@ -487,15 +479,12 @@ void ValueSaveUTest::test_link_by_type() |
| 487 | 479 | store->store_atom(cv); |
| 488 | 480 | store->barrier(); |
| 489 | 481 | |
| 490 | | delete as; |
| 491 | | |
| 492 | 482 | // -------------------- |
| 493 | 483 | // Start it up again. |
| 494 | | |
| 495 | | as = new AtomSpace(); |
| 484 | as = createAtomSpace(); |
| 496 | 485 | hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 497 | 486 | store = StorageNodeCast(hsn); |
| 498 | | store->open(); |
| 487 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 499 | 488 | TS_ASSERT(store->connected()) |
| 500 | 489 | |
| 501 | 490 | // -------------------- |
| … | … | @@ -513,9 +502,10 @@ void ValueSaveUTest::test_link_by_type() |
| 513 | 502 | // only the values on the C-links should be fetched. |
| 514 | 503 | store->fetch_all_atoms_of_type(LIST_LINK); |
| 515 | 504 | store->barrier(); |
| 516 | | // +1 for *-IsKeyFlag-* |
| 505 | // 17 = 4 LIST_LINKs + 8 ConceptNodes + PredicateNode "some pred key" |
| 506 | // + *-TruthValueKey-* + *-IsKeyFlag-* + *-open-* + MonoStorageNode |
| 517 | 507 | printf ("fetched %lu atoms\n", as->get_size()); |
| 518 | | TSM_ASSERT("Wrong number of Atoms fetched!", as->get_size() == 16); |
| 508 | TSM_ASSERT("Wrong number of Atoms fetched!", as->get_size() == 17); |
| 519 | 509 | |
| 520 | 510 | Handle gbf = as->add_node(CONCEPT_NODE, "b float node"); |
| 521 | 511 | Handle gbt = as->add_node(CONCEPT_NODE, "b string node"); |
| … | … | @@ -601,9 +591,6 @@ void ValueSaveUTest::test_link_by_type() |
| 601 | 591 | TS_ASSERT(*gpl == *pvl); |
| 602 | 592 | TS_ASSERT(*gpv == *pvv); |
| 603 | 593 | |
| 604 | | // -------------------- |
| 605 | | delete as; |
| 606 | | |
| 607 | 594 | logger().info("END TEST: %s", __FUNCTION__); |
| 608 | 595 | } |
| 609 | 596 | |
| … | … | @@ -615,10 +602,10 @@ void ValueSaveUTest::test_link_by_type_quoted() |
| 615 | 602 | { |
| 616 | 603 | logger().info("BEGIN TEST: %s", __FUNCTION__); |
| 617 | 604 | |
| 618 | | AtomSpace* as = new AtomSpace(); |
| 605 | AtomSpacePtr as = createAtomSpace(); |
| 619 | 606 | Handle hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 620 | 607 | StorageNodePtr store = StorageNodeCast(hsn); |
| 621 | | store->open(); |
| 608 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 622 | 609 | TS_ASSERT(store->connected()) |
| 623 | 610 | |
| 624 | 611 | Handle key = as->add_node(PREDICATE_NODE, "some (\"pred\"))) key"); |
| … | … | @@ -697,15 +684,12 @@ void ValueSaveUTest::test_link_by_type_quoted() |
| 697 | 684 | store->store_atom(cv); |
| 698 | 685 | store->barrier(); |
| 699 | 686 | |
| 700 | | delete as; |
| 701 | | |
| 702 | 687 | // -------------------- |
| 703 | 688 | // Start it up again. |
| 704 | | |
| 705 | | as = new AtomSpace(); |
| 689 | as = createAtomSpace(); |
| 706 | 690 | hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 707 | 691 | store = StorageNodeCast(hsn); |
| 708 | | store->open(); |
| 692 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 709 | 693 | TS_ASSERT(store->connected()) |
| 710 | 694 | |
| 711 | 695 | // -------------------- |
| … | … | @@ -724,10 +708,10 @@ void ValueSaveUTest::test_link_by_type_quoted() |
| 724 | 708 | store->fetch_all_atoms_of_type(LIST_LINK); |
| 725 | 709 | store->barrier(); |
| 726 | 710 | |
| 727 | | // We created 9 new atoms above, so expect 16 from before plus 9 |
| 728 | | // +1 for *-IsKeyFlag-* |
| 729 | | printf ("fetched %lu atoms, expecting 25\n", as->get_size()); |
| 730 | | TSM_ASSERT("Wrong number of Atoms fetched!", as->get_size() == 25); |
| 711 | // 26 = 9 new atoms above + 4 LIST_LINKs + 8 ConceptNodes (b nodes) |
| 712 | // + *-TruthValueKey-* + *-IsKeyFlag-* + *-open-* + MonoStorageNode |
| 713 | printf ("fetched %lu atoms, expecting 26\n", as->get_size()); |
| 714 | TSM_ASSERT("Wrong number of Atoms fetched!", as->get_size() == 26); |
| 731 | 715 | |
| 732 | 716 | Handle gbf = as->add_node(CONCEPT_NODE, "b float node"); |
| 733 | 717 | Handle gbt = as->add_node(CONCEPT_NODE, "b string node"); |
| … | … | @@ -813,9 +797,6 @@ void ValueSaveUTest::test_link_by_type_quoted() |
| 813 | 797 | TS_ASSERT(*gpl == *pvl); |
| 814 | 798 | TS_ASSERT(*gpv == *pvv); |
| 815 | 799 | |
| 816 | | // -------------------- |
| 817 | | delete as; |
| 818 | | |
| 819 | 800 | logger().info("END TEST: %s", __FUNCTION__); |
| 820 | 801 | } |
| 821 | 802 | |
| … | … | @@ -828,10 +809,10 @@ void ValueSaveUTest::test_incoming() |
| 828 | 809 | { |
| 829 | 810 | logger().info("BEGIN TEST: %s", __FUNCTION__); |
| 830 | 811 | |
| 831 | | AtomSpace* as = new AtomSpace(); |
| 812 | AtomSpacePtr as = createAtomSpace(); |
| 832 | 813 | Handle hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 833 | 814 | StorageNodePtr store = StorageNodeCast(hsn); |
| 834 | | store->open(); |
| 815 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 835 | 816 | TS_ASSERT(store->connected()) |
| 836 | 817 | |
| 837 | 818 | Handle key = as->add_node(PREDICATE_NODE, "some pred key"); |
| … | … | @@ -910,15 +891,12 @@ void ValueSaveUTest::test_incoming() |
| 910 | 891 | store->store_atom(cv); |
| 911 | 892 | store->barrier(); |
| 912 | 893 | |
| 913 | | delete as; |
| 914 | | |
| 915 | 894 | // -------------------- |
| 916 | 895 | // Start it up again. |
| 917 | | |
| 918 | | as = new AtomSpace(); |
| 896 | as = createAtomSpace(); |
| 919 | 897 | hsn = as->add_node(MONO_STORAGE_NODE, std::string(uri)); |
| 920 | 898 | store = StorageNodeCast(hsn); |
| 921 | | store->open(); |
| 899 | store->setValue(as->add_node(PREDICATE_NODE, "*-open-*"), createVoidValue()); |
| 922 | 900 | TS_ASSERT(store->connected()) |
| 923 | 901 | |
| 924 | 902 | // -------------------- |
| … | … | @@ -939,9 +917,10 @@ void ValueSaveUTest::test_incoming() |
| 939 | 917 | store->fetch_incoming_set(gal, false); |
| 940 | 918 | store->fetch_incoming_set(gav, false); |
| 941 | 919 | store->barrier(); |
| 942 | | // +1 for *-IsKeyFlag-* |
| 920 | // 17 = 4 LIST_LINKs + 8 ConceptNodes + PredicateNode "some pred key" |
| 921 | // + *-TruthValueKey-* + *-IsKeyFlag-* + *-open-* + MonoStorageNode |
| 943 | 922 | printf ("fetched %lu atoms\n", as->get_size()); |
| 944 | | TSM_ASSERT("Wrong number of Atoms fetched!", as->get_size() == 16); |
| 923 | TSM_ASSERT("Wrong number of Atoms fetched!", as->get_size() == 17); |
| 945 | 924 | |
| 946 | 925 | Handle gbf = as->add_node(CONCEPT_NODE, "b float node"); |
| 947 | 926 | Handle gbt = as->add_node(CONCEPT_NODE, "b string node"); |
| … | … | @@ -1025,9 +1004,6 @@ void ValueSaveUTest::test_incoming() |
| 1025 | 1004 | TS_ASSERT(*gpl == *pvl); |
| 1026 | 1005 | TS_ASSERT(*gpv == *pvv); |
| 1027 | 1006 | |
| 1028 | | // -------------------- |
| 1029 | | delete as; |
| 1030 | | |
| 1031 | 1007 | logger().info("END TEST: %s", __FUNCTION__); |
| 1032 | 1008 | } |
| 1033 | 1009 | |