X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=tests%2Fcollection.cpp;h=6c9ef195bc2a0ea3166fc5ba07bb2c971425f97b;hb=HEAD;hp=69aaf428c21a2c11d3fa4fce971eefacd95d7331;hpb=3461239f03fd281092e81d0e264a0d5dab165415;p=libs%2Fdatafile.git diff --git a/tests/collection.cpp b/tests/collection.cpp index 69aaf42..6c9ef19 100644 --- a/tests/collection.cpp +++ b/tests/collection.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -21,13 +22,21 @@ public: private: void load(); + void contains(); + void contains_base(); + void contains_loadable(); + void names(); + void names_base(); + void names_loadable(); void fetch(); void nonexistent(); void type_mismatch(); void create(); + void list_loadable(); void name_collision(); }; + class Base { public: @@ -47,7 +56,15 @@ public: }; class Foo: public Base -{ }; +{ +private: + static unsigned create_count; + +public: + Foo(); + + static unsigned get_create_count() { return create_count; } +}; class Bar: public Base { }; @@ -55,8 +72,25 @@ class Bar: public Base class Sub: public Bar { }; +class Bus: public Bar +{ }; + + +class TestSource: public DataFile::CollectionSource +{ +public: + virtual bool is_loadable(const DataFile::CollectionItemTypeBase &, const std::string &) const; + virtual NameList get_names(const DataFile::CollectionItemTypeBase &) const; + virtual void load(DataFile::Collection &, const DataFile::CollectionItemTypeBase &, const std::string &) const; + virtual IO::Seekable *open(const string &) const { return 0; } +}; + + class TestCollection: public DataFile::Collection { +private: + TestSource source; + public: TestCollection(); @@ -64,13 +98,21 @@ private: Foo *create_foo(const string &); }; + CollectionTests::CollectionTests() { add(&CollectionTests::load, "Load objects"); + add(&CollectionTests::contains, "Containment test"); + add(&CollectionTests::contains_base, "Base class containment test"); + add(&CollectionTests::contains_loadable, "Loadable containment test"); + add(&CollectionTests::names, "List object names"); + add(&CollectionTests::names_base, "List base class object names"); + add(&CollectionTests::names_loadable, "List loadable object names"); add(&CollectionTests::fetch, "Fetch objects"); add(&CollectionTests::nonexistent, "Nonexistent object").expect_throw(); add(&CollectionTests::type_mismatch, "Type mismatch").expect_throw(); add(&CollectionTests::create, "Create object"); + add(&CollectionTests::list_loadable, "List loadable objects"); add(&CollectionTests::name_collision, "Name collision").expect_throw(); collection = new TestCollection; @@ -87,7 +129,8 @@ void CollectionTests::load() "foo \"a\" { tag 1; };\n" "foo \"b\" { tag 2; };\n" "bar \"c\" { tag 3; };\n" - "sub \"d\" { tag 4; };\n"; + "sub \"d\" { tag 4; };\n" + "bus \"e\" { tag 5; };\n"; IO::Memory mem(input, sizeof(input)-1); DataFile::Parser parser(mem, "-"); @@ -95,6 +138,57 @@ void CollectionTests::load() loader.load(parser); } +void CollectionTests::contains() +{ + const TestCollection *ccoll = collection; + EXPECT(ccoll->contains("a")); + EXPECT(ccoll->contains("c")); + EXPECT(!ccoll->contains("c")); +} + +void CollectionTests::contains_base() +{ + const TestCollection *ccoll = collection; + EXPECT(ccoll->contains("d")); + EXPECT(ccoll->contains("d")); +} + +void CollectionTests::contains_loadable() +{ + const TestCollection *ccoll = collection; + EXPECT(!ccoll->contains("f")); + EXPECT(collection->contains("f")); +} + +void CollectionTests::names() +{ + const TestCollection *ccoll = collection; + list nm = ccoll->get_names(); + EXPECT_EQUAL(nm.size(), 2); + set nm_set(nm.begin(), nm.end()); + EXPECT_EQUAL(nm_set.count("a"), 1); + EXPECT_EQUAL(nm_set.count("b"), 1); +} + +void CollectionTests::names_base() +{ + const TestCollection *ccoll = collection; + list nm = ccoll->get_names(); + EXPECT_EQUAL(nm.size(), 3); + set nm_set(nm.begin(), nm.end()); + EXPECT_EQUAL(nm_set.count("c"), 1); + EXPECT_EQUAL(nm_set.count("d"), 1); + EXPECT_EQUAL(nm_set.count("e"), 1); +} + +void CollectionTests::names_loadable() +{ + list nm = collection->get_names(); + EXPECT_EQUAL(nm.size(), 3); + set nm_set(nm.begin(), nm.end()); + EXPECT_EQUAL(nm_set.count("f"), 1); +} + void CollectionTests::fetch() { const TestCollection *ccoll = collection; @@ -102,6 +196,7 @@ void CollectionTests::fetch() EXPECT_EQUAL(ccoll->get("b").get_tag(), 2); EXPECT_EQUAL(ccoll->get("c").get_tag(), 3); EXPECT_EQUAL(ccoll->get("d").get_tag(), 4); + EXPECT_EQUAL(ccoll->get("d").get_tag(), 4); } void CollectionTests::nonexistent() @@ -116,9 +211,19 @@ void CollectionTests::type_mismatch() void CollectionTests::create() { + unsigned foo_count = Foo::get_create_count(); Foo &f = collection->get("f"); Foo &f2 = collection->get("f"); EXPECT_EQUAL(&f2, &f); + EXPECT(Foo::get_create_count()>foo_count); +} + +void CollectionTests::list_loadable() +{ + list nm = collection->get_list(); + EXPECT_EQUAL(nm.size(), 3); + set nm_set(nm.begin(), nm.end()); + EXPECT_EQUAL(nm_set.size(), nm.size()); } void CollectionTests::name_collision() @@ -128,21 +233,53 @@ void CollectionTests::name_collision() a.release(); } + Base::Base(): tag(0) { } + Base::Loader::Loader(Base &b): DataFile::ObjectLoader(b) { add("tag", &Base::tag); } + +unsigned Foo::create_count = 0; + +Foo::Foo() +{ + ++create_count; +} + + +bool TestSource::is_loadable(const DataFile::CollectionItemTypeBase &, const string &name) const +{ + return name=="f"; +} + +DataFile::CollectionSource::NameList TestSource::get_names(const DataFile::CollectionItemTypeBase &) const +{ + NameList names; + names.push_back("f"); + return names; +} + +void TestSource::load(DataFile::Collection &coll, const DataFile::CollectionItemTypeBase &, const string &name) const +{ + if(name=="f") + coll.add("f", new Foo); +} + + TestCollection::TestCollection() { - add_type().keyword("foo").create(&TestCollection::create_foo); + add_type().keyword("foo").creator(&TestCollection::create_foo); add_type().keyword("bar"); - add_type().keyword("sub").store_as(); + add_type().keyword("sub").base(); + add_type().keyword("bus").base(); + add_source(source); } Foo *TestCollection::create_foo(const string &)