Cosmetic changes

[libs/datafile.git] / tests / collection.cpp

diff --git a/tests/collection.cpp b/tests/collection.cpp
index bb72c03fbba536f3cce42cf6cfdea6e52c9f45ba..6c9ef195bc2a0ea3166fc5ba07bb2c971425f97b 100644 (file)
--- a/tests/collection.cpp
+++ b/tests/collection.cpp
@@ -1,3 +1,4 @@
+#include <set>
 #include <msp/datafile/collection.h>
 #include <msp/datafile/objectloader.h>
 #include <msp/io/memory.h>
@@ -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<key_error>();
        add(&CollectionTests::type_mismatch, "Type mismatch").expect_throw<Msp::type_mismatch>();
        add(&CollectionTests::create, "Create object");
+       add(&CollectionTests::list_loadable, "List loadable objects");
        add(&CollectionTests::name_collision, "Name collision").expect_throw<Msp::key_error>();
 
        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<Foo>("a"));
+       EXPECT(ccoll->contains<Bar>("c"));
+       EXPECT(!ccoll->contains<Foo>("c"));
+}
+
+void CollectionTests::contains_base()
+{
+       const TestCollection *ccoll = collection;
+       EXPECT(ccoll->contains<Bar>("d"));
+       EXPECT(ccoll->contains<Sub>("d"));
+}
+
+void CollectionTests::contains_loadable()
+{
+       const TestCollection *ccoll = collection;
+       EXPECT(!ccoll->contains<Foo>("f"));
+       EXPECT(collection->contains<Foo>("f"));
+}
+
+void CollectionTests::names()
+{
+       const TestCollection *ccoll = collection;
+       list<string> nm = ccoll->get_names<Foo>();
+       EXPECT_EQUAL(nm.size(), 2);
+       set<string> 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<string> nm = ccoll->get_names<Bar>();
+       EXPECT_EQUAL(nm.size(), 3);
+       set<string> 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<string> nm = collection->get_names<Foo>();
+       EXPECT_EQUAL(nm.size(), 3);
+       set<string> 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<Foo>("b").get_tag(), 2);
        EXPECT_EQUAL(ccoll->get<Bar>("c").get_tag(), 3);
        EXPECT_EQUAL(ccoll->get<Bar>("d").get_tag(), 4);
+       EXPECT_EQUAL(ccoll->get<Sub>("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<Foo>("f");
        Foo &f2 = collection->get<Foo>("f");
        EXPECT_EQUAL(&f2, &f);
+       EXPECT(Foo::get_create_count()>foo_count);
+}
+
+void CollectionTests::list_loadable()
+{
+       list<Foo *> nm = collection->get_list<Foo>();
+       EXPECT_EQUAL(nm.size(), 3);
+       set<Foo *> 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<Base>(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<Foo>().keyword("foo").creator(&TestCollection::create_foo);
        add_type<Bar>().keyword("bar");
-       add_type<Sub>().keyword("sub").store_as<Bar>();
+       add_type<Sub>().keyword("sub").base<Bar>();
+       add_type<Bus>().keyword("bus").base<Bar>();
+       add_source(source);
 }
 
 Foo *TestCollection::create_foo(const string &)