X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=tests%2Fcollection.cpp;h=6c9ef195bc2a0ea3166fc5ba07bb2c971425f97b;hb=HEAD;hp=bbcc6c9fce28bab325341149a1123be8acf09f03;hpb=92bcf7a5e69a7c8e6055a77a39f356c293b89445;p=libs%2Fdatafile.git

diff --git a/tests/collection.cpp b/tests/collection.cpp
index bbcc6c9..6c9ef19 100644
--- a/tests/collection.cpp
+++ b/tests/collection.cpp
@@ -23,13 +23,16 @@ public:
 private:
 	void load();
 	void contains();
-	void contains_future();
+	void contains_base();
+	void contains_loadable();
 	void names();
-	void names_future();
+	void names_base();
+	void names_loadable();
 	void fetch();
 	void nonexistent();
 	void type_mismatch();
 	void create();
+	void list_loadable();
 	void name_collision();
 };
 
@@ -69,9 +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();
 
@@ -84,13 +103,16 @@ CollectionTests::CollectionTests()
 {
 	add(&CollectionTests::load, "Load objects");
 	add(&CollectionTests::contains, "Containment test");
-	add(&CollectionTests::contains_future, "Future 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_future, "List future 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;
@@ -107,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, "-");
@@ -123,7 +146,14 @@ void CollectionTests::contains()
 	EXPECT(!ccoll->contains<Foo>("c"));
 }
 
-void CollectionTests::contains_future()
+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"));
@@ -140,7 +170,18 @@ void CollectionTests::names()
 	EXPECT_EQUAL(nm_set.count("b"), 1);
 }
 
-void CollectionTests::names_future()
+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);
@@ -155,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()
@@ -176,6 +218,14 @@ void CollectionTests::create()
 	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()
 {
 	RefPtr<Foo> a = new Foo;
@@ -204,12 +254,32 @@ Foo::Foo()
 }
 
 
+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_future<Foo>("f");
+	add_type<Sub>().keyword("sub").base<Bar>();
+	add_type<Bus>().keyword("bus").base<Bar>();
+	add_source(source);
 }
 
 Foo *TestCollection::create_foo(const string &)