summaryrefslogtreecommitdiff
path: root/test
diff options
context:
space:
mode:
Diffstat (limited to 'test')
-rw-r--r--test/test-assetFactory.cpp24
-rw-r--r--test/test-collection.cpp287
-rw-r--r--test/test-network.cpp68
-rw-r--r--test/test-render.cpp13
4 files changed, 337 insertions, 55 deletions
diff --git a/test/test-assetFactory.cpp b/test/test-assetFactory.cpp
index 9bade82..68ce6a6 100644
--- a/test/test-assetFactory.cpp
+++ b/test/test-assetFactory.cpp
@@ -71,7 +71,7 @@ public:
sceneRenderer.render(*this);
}
- Collection<const Renderable> objects;
+ SharedCollection<const Renderable> objects;
private:
SceneRenderer sceneRenderer;
@@ -84,7 +84,7 @@ BOOST_AUTO_TEST_CASE(surfaces, *boost::unit_test::timeout(5))
BOOST_CHECK_EQUAL(4, mf->assets.size());
auto gravelAsset = mf->assets.at("terrain.surface.gravel");
BOOST_REQUIRE(gravelAsset);
- auto gravel = std::dynamic_pointer_cast<Surface>(gravelAsset);
+ auto gravel = gravelAsset.dynamicCast<Surface>();
BOOST_REQUIRE(gravel);
BOOST_REQUIRE_EQUAL(gravel->name, "Gravel");
BOOST_REQUIRE_EQUAL(gravel->colorBias, RGB {.9F});
@@ -111,14 +111,14 @@ BOOST_AUTO_TEST_CASE(brush47xml, *boost::unit_test::timeout(5))
BOOST_CHECK_EQUAL(1, mf->assets.size());
auto brush47 = mf->assets.at("brush-47");
BOOST_REQUIRE(brush47);
- auto brush47rvc = std::dynamic_pointer_cast<RailVehicleClass>(brush47);
+ auto brush47rvc = brush47.dynamicCast<RailVehicleClass>();
BOOST_REQUIRE(brush47rvc);
BOOST_REQUIRE(brush47rvc->bodyMesh);
BOOST_REQUIRE(brush47rvc->bogies.front());
BOOST_REQUIRE(brush47rvc->bogies.back());
auto railVehicle = std::make_shared<RailVehicle>(brush47rvc);
- objects.objects.push_back(brush47rvc);
+ objects.emplace(brush47rvc);
render(10000);
}
@@ -130,14 +130,14 @@ BOOST_AUTO_TEST_CASE(foliage, *boost::unit_test::timeout(5))
gameState.assets = mf->assets;
auto tree_01_1 = mf->assets.at("Tree-01-1");
BOOST_REQUIRE(tree_01_1);
- auto tree_01_1_f = std::dynamic_pointer_cast<Foliage>(tree_01_1);
+ auto tree_01_1_f = tree_01_1.dynamicCast<Foliage>();
BOOST_REQUIRE(tree_01_1_f);
auto plant1 = std::make_shared<Plant>(tree_01_1_f, Location {{-2000, 2000, 0}, {0, 0, 0}});
auto plant2 = std::make_shared<Plant>(tree_01_1_f, Location {{3000, -4000, 0}, {0, 1, 0}});
auto plant3 = std::make_shared<Plant>(tree_01_1_f, Location {{-2000, -4000, 0}, {0, 2, 0}});
auto plant4 = std::make_shared<Plant>(tree_01_1_f, Location {{3000, 2000, 0}, {0, 3, 0}});
- objects.objects.push_back(tree_01_1_f);
+ objects.emplace(tree_01_1_f);
render(6000);
}
@@ -151,22 +151,22 @@ BOOST_AUTO_TEST_CASE(lights, *boost::unit_test::timeout(5))
BOOST_REQUIRE(rlight);
auto oldlamp = mf->assets.at("old-lamp");
BOOST_REQUIRE(oldlamp);
- auto rlight_f = std::dynamic_pointer_cast<Illuminator>(rlight);
+ auto rlight_f = rlight.dynamicCast<Illuminator>();
BOOST_REQUIRE(rlight_f);
- auto oldlamp_f = std::dynamic_pointer_cast<Illuminator>(oldlamp);
+ auto oldlamp_f = oldlamp.dynamicCast<Illuminator>();
BOOST_REQUIRE(oldlamp_f);
auto light1 = std::make_shared<Light>(oldlamp_f, Location {{0, 0, 0}, {0, 0, 0}});
auto light2 = std::make_shared<Light>(rlight_f, Location {{-4000, 0, 0}, {0, 2, 0}});
auto light3 = std::make_shared<Light>(rlight_f, Location {{-4000, -4000, 0}, {0, 1, 0}});
auto light4 = std::make_shared<Light>(oldlamp_f, Location {{3000, 4600, 0}, {0, 2, 0}});
- objects.objects.push_back(rlight_f);
- objects.objects.push_back(oldlamp_f);
+ objects.emplace(rlight_f);
+ objects.emplace(oldlamp_f);
// yes I'm hacking some floor to light up as though its a bush
- auto floorf = std::dynamic_pointer_cast<Foliage>(mf->assets.at("floor"));
+ auto floorf = mf->assets.at("floor").dynamicCast<Foliage>();
auto floor = std::make_shared<Plant>(floorf, Location {});
- objects.objects.push_back(floorf);
+ objects.emplace(floorf);
render(6000);
}
diff --git a/test/test-collection.cpp b/test/test-collection.cpp
index 00204fc..620d3ab 100644
--- a/test/test-collection.cpp
+++ b/test/test-collection.cpp
@@ -21,6 +21,12 @@ public:
return false;
}
+ [[nodiscard]] virtual bool
+ yes() const
+ {
+ return true;
+ }
+
unsigned int total {0};
};
@@ -34,27 +40,63 @@ public:
}
};
-using TestCollection = Collection<Base>;
+class Sub1 : public Sub { };
+
+class Sub2 : public Sub { };
+
+class Base2 {
+public:
+ virtual ~Base2() = default;
+};
+
+class Multi : public Sub1, public Base2 { };
+
+using TestCollection = SharedCollection<Base, Sub>;
-BOOST_TEST_DONT_PRINT_LOG_VALUE(Collection<Base>::Objects::const_iterator)
-BOOST_TEST_DONT_PRINT_LOG_VALUE(Collection<Base>::Objects::const_reverse_iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestCollection::Objects::iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestCollection::Objects::const_iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestCollection::Objects::const_reverse_iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestCollection::OtherObjects<Sub>::iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestCollection::OtherObjects<Sub>::const_iterator)
BOOST_FIXTURE_TEST_SUITE(tc, TestCollection)
BOOST_AUTO_TEST_CASE(empty)
{
+ BOOST_CHECK(TestCollection::empty());
BOOST_REQUIRE(!apply(&Base::add));
const auto i = applyOne(&Base::add);
BOOST_CHECK_EQUAL(i, end());
+ BOOST_CHECK(!find<Base>());
+ BOOST_CHECK(!find<Sub>());
+ BOOST_CHECK(!find<Sub1>());
}
BOOST_AUTO_TEST_CASE(a_base)
{
auto b = create<Base>();
+ BOOST_CHECK_EQUAL(objects.size(), 1);
+ BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
BOOST_REQUIRE(apply(&Base::add));
BOOST_CHECK_EQUAL(b->total, 1);
const auto i = applyOne(&Base::add);
BOOST_CHECK_EQUAL(i, end());
+ BOOST_CHECK_EQUAL(b.get(), find<Base>());
+ BOOST_CHECK(!find<Sub>());
+ BOOST_CHECK(!find<Sub1>());
+}
+
+BOOST_AUTO_TEST_CASE(emplace_others)
+{
+ auto b = emplace(std::make_shared<Base>());
+ BOOST_CHECK_EQUAL(objects.size(), 1);
+ BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
+ auto s = emplace(std::make_shared<Sub>());
+ BOOST_CHECK_EQUAL(objects.size(), 2);
+ BOOST_CHECK_EQUAL(std::get<OtherObjects<Sub>>(otherObjects).size(), 1);
+ BOOST_CHECK_EQUAL(b.get(), find<Base>());
+ BOOST_CHECK_EQUAL(s.get(), find<Sub>());
+ BOOST_CHECK(!find<Sub1>());
}
BOOST_AUTO_TEST_CASE(a_rbase)
@@ -69,6 +111,8 @@ BOOST_AUTO_TEST_CASE(a_rbase)
BOOST_AUTO_TEST_CASE(a_sub)
{
auto s = create<Sub>();
+ BOOST_CHECK_EQUAL(objects.size(), 1);
+ BOOST_CHECK_EQUAL(std::get<OtherObjects<Sub>>(otherObjects).size(), 1);
BOOST_REQUIRE(apply(&Base::add));
BOOST_CHECK_EQUAL(s->total, 2);
const auto i = applyOne(&Base::add);
@@ -76,6 +120,243 @@ BOOST_AUTO_TEST_CASE(a_sub)
BOOST_CHECK_EQUAL(*i, s);
}
+BOOST_AUTO_TEST_CASE(filter)
+{
+ static_assert(TestCollection::idx<Sub>() == 0);
+ static_assert(TestCollection::idx<const Sub>() == 0);
+ static_assert(TestCollection::idx<Sub1>() == 0);
+ static_assert(TestCollection::idx<const Sub1>() == 0);
+ create<Base>();
+ BOOST_CHECK_EQUAL(1, apply<Base>(&Base::yes));
+ BOOST_CHECK_EQUAL(0, apply<Sub>(&Base::yes));
+ BOOST_CHECK_EQUAL(0, apply<Sub1>(&Base::yes));
+ BOOST_CHECK_EQUAL(objects.begin(), applyOne<Base>(&Base::yes));
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).end(), applyOne<Sub>(&Base::yes));
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).end(), applyOne<Sub1>(&Base::yes));
+ create<Sub>();
+ BOOST_CHECK_EQUAL(2, apply<Base>(&Base::yes));
+ BOOST_CHECK_EQUAL(1, apply<Sub>(&Base::yes));
+ BOOST_CHECK_EQUAL(0, apply<Sub1>(&Base::yes));
+ BOOST_CHECK_EQUAL(objects.begin(), applyOne<Base>(&Base::yes));
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).begin(), applyOne<Sub>(&Base::yes));
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).end(), applyOne<Sub1>(&Base::yes));
+ create<Sub1>();
+ BOOST_CHECK_EQUAL(3, apply<Base>(&Base::yes));
+ BOOST_CHECK_EQUAL(2, apply<Sub>(&Base::yes));
+ BOOST_CHECK_EQUAL(1, apply<Sub1>(&Base::yes));
+ BOOST_CHECK_EQUAL(objects.begin(), applyOne<Base>(&Base::yes));
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).begin(), applyOne<Sub>(&Base::yes));
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).begin() + 1, applyOne<Sub1>(&Base::yes));
+
+ BOOST_CHECK_EQUAL(std::get<idx<Sub>()>(otherObjects).size(), 2);
+ BOOST_CHECK_EQUAL(std::get<idx<Sub1>()>(otherObjects).size(), 2);
+
+ BOOST_CHECK_EQUAL(&objects, &containerFor<Base>());
+ BOOST_CHECK_EQUAL(&std::get<0>(otherObjects), &containerFor<Sub>());
+ BOOST_CHECK_EQUAL(&std::get<0>(otherObjects), &containerFor<Sub1>());
+}
+
+BOOST_AUTO_TEST_CASE(begin_end)
+{
+ BOOST_CHECK_EQUAL(0, std::distance(begin(), end()));
+ create<Sub>();
+ create<Base>();
+ BOOST_CHECK_EQUAL(2, std::distance(begin(), end()));
+}
+
+BOOST_AUTO_TEST_CASE(rbegin_rend)
+{
+ BOOST_CHECK_EQUAL(0, std::distance(rbegin(), rend()));
+ create<Sub>();
+ create<Base>();
+ BOOST_CHECK_EQUAL(2, std::distance(rbegin(), rend()));
+}
+
+BOOST_AUTO_TEST_CASE(createCreate)
+{
+ auto b = findOrCreate<Base>();
+ BOOST_CHECK(b);
+ auto b2 = findOrCreate<Base>();
+ BOOST_CHECK_EQUAL(b, b2);
+ auto s = findOrCreate<Sub>();
+ BOOST_CHECK_NE(s, b);
+ auto s2 = findOrCreate<Sub>();
+ BOOST_CHECK_EQUAL(s, s2);
+}
+
+BOOST_AUTO_TEST_CASE(createCreateSub)
+{
+ auto s = findOrCreate<Sub>();
+ auto b = findOrCreate<Base>();
+ BOOST_CHECK_EQUAL(s, b);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+using TestUniqueCollection = UniqueCollection<Base, Sub>;
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestUniqueCollection::Objects::const_iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestUniqueCollection::Objects::const_reverse_iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestUniqueCollection::Objects::iterator)
+BOOST_TEST_DONT_PRINT_LOG_VALUE(TestUniqueCollection::Objects::reverse_iterator)
+
+BOOST_FIXTURE_TEST_SUITE(utc, TestUniqueCollection)
+
+BOOST_AUTO_TEST_CASE(unique_create)
+{
+ create<Base>();
+ BOOST_CHECK_EQUAL(objects.size(), 1);
+ BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
+ create<Sub>();
+ BOOST_CHECK_EQUAL(objects.size(), 2);
+ BOOST_CHECK_EQUAL(std::get<OtherObjects<Sub>>(otherObjects).size(), 1);
+}
+
+BOOST_AUTO_TEST_CASE(move_assign)
+{
+ create<Base>();
+ create<Sub>();
+
+ TestUniqueCollection::Objects other;
+ TestUniqueCollection::operator=(std::move(other));
+ BOOST_CHECK(objects.empty());
+ BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
+
+ other.push_back(std::make_unique<Sub>());
+ other.push_back(std::make_unique<Base>());
+ TestUniqueCollection::operator=(std::move(other));
+ BOOST_CHECK_EQUAL(objects.size(), 2);
+ BOOST_CHECK_EQUAL(std::get<OtherObjects<Sub>>(otherObjects).size(), 1);
+ BOOST_CHECK(other.empty());
+}
+
+BOOST_AUTO_TEST_CASE(clearAll)
+{
+ create<Base>();
+ create<Sub>();
+ emplace(std::make_unique<Base>());
+ emplace(std::make_unique<Sub>());
+
+ clear();
+ BOOST_CHECK(objects.empty());
+ BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
+}
+
+BOOST_AUTO_TEST_CASE(removeAllOfSub)
+{
+ create<Base>();
+ create<Sub>();
+ emplace(std::make_unique<Base>());
+ emplace(std::make_unique<Sub>());
+ emplace(std::make_unique<Sub1>());
+
+ BOOST_CHECK_EQUAL(removeAll<Sub>(), 3);
+ BOOST_CHECK_EQUAL(objects.size(), 2);
+ BOOST_CHECK(std::get<OtherObjects<Sub>>(otherObjects).empty());
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_FIXTURE_TEST_SUITE(btc, UniqueCollection<Base>)
+
+BOOST_AUTO_TEST_CASE(no_others)
+{
+ create<Base>();
+ create<Sub>();
+ emplace(std::make_unique<Base>());
+ emplace(std::make_unique<Sub>());
+}
+
+BOOST_AUTO_TEST_CASE(applyAll)
+{
+ create<Base>();
+ BOOST_CHECK_EQUAL(0, apply<Sub>(&Base::add));
+ BOOST_CHECK_EQUAL(1, apply<Base>(&Base::add));
+ create<Sub>();
+ BOOST_CHECK_EQUAL(1, apply<Sub>(&Base::add));
+ BOOST_CHECK_EQUAL(2, apply<Base>(&Base::add));
+}
+
+BOOST_AUTO_TEST_CASE(applyOneType)
+{
+ create<Base>();
+ BOOST_CHECK_EQUAL(objects.end(), applyOne<Sub>(&Base::yes));
+ BOOST_CHECK_EQUAL(objects.begin(), applyOne<Base>(&Base::yes));
+ create<Sub>();
+ BOOST_CHECK_EQUAL(objects.begin() + 1, applyOne<Sub>(&Base::yes));
+ BOOST_CHECK_EQUAL(objects.begin(), applyOne<Base>(&Base::yes));
+ create<Sub1>();
+ BOOST_CHECK_EQUAL(objects.begin() + 2, applyOne<Sub1>(&Base::yes));
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+using MultiCollection = Collection<std::unique_ptr<Base>, Multi, Sub, Base2>;
+
+BOOST_FIXTURE_TEST_SUITE(multi, MultiCollection)
+
+BOOST_AUTO_TEST_CASE(addMulti)
+{
+ static_assert(MultiCollection::idx<Multi>() == 0);
+ static_assert(MultiCollection::idx<Sub>() == 1);
+ static_assert(MultiCollection::idx<Base2>() == 2);
+ create<Base>();
+ BOOST_CHECK_EQUAL(objects.size(), 1);
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+ BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 0);
+ BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+ create<Sub>();
+ BOOST_CHECK_EQUAL(objects.size(), 2);
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+ BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 1);
+ BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+ create<Sub1>();
+ BOOST_CHECK_EQUAL(objects.size(), 3);
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+ BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 2);
+ BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+ create<Sub2>();
+ BOOST_CHECK_EQUAL(objects.size(), 4);
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+ BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 3);
+ BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+ create<Multi>();
+ BOOST_CHECK_EQUAL(size(), 5);
+ BOOST_CHECK_EQUAL(size<Multi>(), 1);
+ BOOST_CHECK_EQUAL(size<Sub>(), 4);
+ BOOST_CHECK_EQUAL(size<Base2>(), 1);
+}
+
+BOOST_AUTO_TEST_CASE(removeMulti)
+{
+ create<Base>();
+ create<Sub>();
+ create<Sub1>();
+ create<Sub2>();
+ create<Multi>();
+ BOOST_CHECK_EQUAL(objects.size(), 5);
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 1);
+ BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 4);
+ BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 1);
+
+ BOOST_CHECK_EQUAL(removeAll<Multi>(), 1);
+ BOOST_CHECK_EQUAL(objects.size(), 4);
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+ BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 3);
+ BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+
+ BOOST_CHECK_EQUAL(removeAll<Sub>(), 3);
+ BOOST_CHECK_EQUAL(objects.size(), 1);
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+ BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 0);
+ BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+
+ BOOST_CHECK_EQUAL(removeAll<Base>(), 1);
+ BOOST_CHECK_EQUAL(objects.size(), 0);
+ BOOST_CHECK_EQUAL(std::get<0>(otherObjects).size(), 0);
+ BOOST_CHECK_EQUAL(std::get<1>(otherObjects).size(), 0);
+ BOOST_CHECK_EQUAL(std::get<2>(otherObjects).size(), 0);
+}
+
BOOST_AUTO_TEST_SUITE_END()
BOOST_AUTO_TEST_CASE(wrapped_ptr_file_cons)
diff --git a/test/test-network.cpp b/test/test-network.cpp
index 51fea8b..19a740e 100644
--- a/test/test-network.cpp
+++ b/test/test-network.cpp
@@ -139,83 +139,83 @@ BOOST_DATA_TEST_CASE(newNodeAt_new, INVALID_NODES, p)
BOOST_AUTO_TEST_CASE(network_joins)
{
// Ends
- BOOST_CHECK(links.objects[2]->ends[1].nexts.empty());
+ BOOST_CHECK(links[2]->ends[1].nexts.empty());
// Join 0 <-> 1
- BOOST_REQUIRE_EQUAL(links.objects[0]->ends[1].nexts.size(), 2);
- BOOST_CHECK_EQUAL(links.objects[0]->ends[1].nexts[0].first.lock().get(), links.objects[1].get());
- BOOST_CHECK_EQUAL(links.objects[0]->ends[1].nexts[0].second, 0);
- BOOST_CHECK_EQUAL(links.objects[0]->ends[1].nexts[1].first.lock().get(), links.objects[5].get());
- BOOST_CHECK_EQUAL(links.objects[0]->ends[1].nexts[1].second, 0);
- BOOST_REQUIRE_EQUAL(links.objects[1]->ends[0].nexts.size(), 2);
- BOOST_CHECK_EQUAL(links.objects[1]->ends[0].nexts[0].first.lock().get(), links.objects[0].get());
- BOOST_CHECK_EQUAL(links.objects[1]->ends[0].nexts[0].second, 1);
- BOOST_CHECK_EQUAL(links.objects[1]->ends[0].nexts[1].first.lock().get(), links.objects[5].get());
- BOOST_CHECK_EQUAL(links.objects[1]->ends[0].nexts[1].second, 0);
+ BOOST_REQUIRE_EQUAL(links[0]->ends[1].nexts.size(), 2);
+ BOOST_CHECK_EQUAL(links[0]->ends[1].nexts[0].first.lock().get(), links[1].get());
+ BOOST_CHECK_EQUAL(links[0]->ends[1].nexts[0].second, 0);
+ BOOST_CHECK_EQUAL(links[0]->ends[1].nexts[1].first.lock().get(), links[5].get());
+ BOOST_CHECK_EQUAL(links[0]->ends[1].nexts[1].second, 0);
+ BOOST_REQUIRE_EQUAL(links[1]->ends[0].nexts.size(), 2);
+ BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[0].first.lock().get(), links[0].get());
+ BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[0].second, 1);
+ BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[1].first.lock().get(), links[5].get());
+ BOOST_CHECK_EQUAL(links[1]->ends[0].nexts[1].second, 0);
// Join 1 <-> 2
- BOOST_REQUIRE_EQUAL(links.objects[1]->ends[1].nexts.size(), 2);
- BOOST_CHECK_EQUAL(links.objects[1]->ends[1].nexts[0].first.lock().get(), links.objects[2].get());
- BOOST_CHECK_EQUAL(links.objects[1]->ends[1].nexts[0].second, 0);
- BOOST_REQUIRE_EQUAL(links.objects[2]->ends[0].nexts.size(), 2);
- BOOST_CHECK_EQUAL(links.objects[2]->ends[0].nexts[0].first.lock().get(), links.objects[1].get());
- BOOST_CHECK_EQUAL(links.objects[2]->ends[0].nexts[0].second, 1);
+ BOOST_REQUIRE_EQUAL(links[1]->ends[1].nexts.size(), 2);
+ BOOST_CHECK_EQUAL(links[1]->ends[1].nexts[0].first.lock().get(), links[2].get());
+ BOOST_CHECK_EQUAL(links[1]->ends[1].nexts[0].second, 0);
+ BOOST_REQUIRE_EQUAL(links[2]->ends[0].nexts.size(), 2);
+ BOOST_CHECK_EQUAL(links[2]->ends[0].nexts[0].first.lock().get(), links[1].get());
+ BOOST_CHECK_EQUAL(links[2]->ends[0].nexts[0].second, 1);
}
BOOST_DATA_TEST_CASE(routeTo_nodeNotInNetwork, INVALID_NODES, dest)
{
- const auto & start = links.objects.front()->ends[1];
+ const auto & start = links[0]->ends[1];
BOOST_CHECK_THROW((void)routeFromTo(start, dest), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(routeTo_noSteps)
{
- const auto & start = links.objects.front()->ends[1];
+ const auto & start = links[0]->ends[1];
auto r = this->routeFromTo(start, p100);
BOOST_CHECK(r.empty());
}
BOOST_AUTO_TEST_CASE(routeTo_upStream_to2)
{
- const auto & start = links.objects.front()->ends[1];
+ const auto & start = links[0]->ends[1];
auto r = this->routeFromTo(start, p200);
BOOST_REQUIRE_EQUAL(r.size(), 1);
- BOOST_CHECK_EQUAL(r[0].first.lock().get(), links.objects[1].get());
+ BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[1].get());
}
BOOST_AUTO_TEST_CASE(routeTo_upStream_to3)
{
- const auto & start = links.objects[0]->ends[1];
+ const auto & start = links[0]->ends[1];
auto r = this->routeFromTo(start, p300);
BOOST_REQUIRE_EQUAL(r.size(), 2);
- BOOST_CHECK_EQUAL(r[0].first.lock().get(), links.objects[1].get());
- BOOST_CHECK_EQUAL(r[1].first.lock().get(), links.objects[2].get());
+ BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[1].get());
+ BOOST_CHECK_EQUAL(r[1].first.lock().get(), links[2].get());
}
BOOST_AUTO_TEST_CASE(routeTo_downStream_to0)
{
- const auto & start = links.objects[2]->ends[0];
+ const auto & start = links[2]->ends[0];
auto r = this->routeFromTo(start, p000);
BOOST_REQUIRE_EQUAL(r.size(), 2);
- BOOST_CHECK_EQUAL(r[0].first.lock().get(), links.objects[1].get());
- BOOST_CHECK_EQUAL(r[1].first.lock().get(), links.objects[0].get());
+ BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[1].get());
+ BOOST_CHECK_EQUAL(r[1].first.lock().get(), links[0].get());
}
BOOST_AUTO_TEST_CASE(routeTo_upStream_3to300)
{
- const auto & start = links.objects[3]->ends[1];
+ const auto & start = links[3]->ends[1];
auto r = this->routeFromTo(start, p300);
BOOST_REQUIRE_EQUAL(r.size(), 2);
- BOOST_CHECK_EQUAL(r[0].first.lock().get(), links.objects[4].get());
- BOOST_CHECK_EQUAL(r[1].first.lock().get(), links.objects[2].get());
+ BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[4].get());
+ BOOST_CHECK_EQUAL(r[1].first.lock().get(), links[2].get());
}
BOOST_AUTO_TEST_CASE(routeTo_downStream_3to300)
{
- const auto & start = links.objects[3]->ends[0];
+ const auto & start = links[3]->ends[0];
auto r = this->routeFromTo(start, p300);
BOOST_REQUIRE_EQUAL(r.size(), 3);
- BOOST_CHECK_EQUAL(r[0].first.lock().get(), links.objects[0].get());
- BOOST_CHECK_EQUAL(r[1].first.lock().get(), links.objects[1].get());
- BOOST_CHECK_EQUAL(r[2].first.lock().get(), links.objects[2].get());
+ BOOST_CHECK_EQUAL(r[0].first.lock().get(), links[0].get());
+ BOOST_CHECK_EQUAL(r[1].first.lock().get(), links[1].get());
+ BOOST_CHECK_EQUAL(r[2].first.lock().get(), links[2].get());
}
BOOST_AUTO_TEST_SUITE_END()
diff --git a/test/test-render.cpp b/test/test-render.cpp
index 8390d25..a6e28bc 100644
--- a/test/test-render.cpp
+++ b/test/test-render.cpp
@@ -41,7 +41,7 @@ public:
terrain->point(GeoData::VertexHandle {517}).z = 100'000;
terrain->generateMeshes();
gameState->assets = AssetFactory::loadAll(RESDIR);
- brush47rvc = std::dynamic_pointer_cast<RailVehicleClass>(gameState->assets.at("brush-47"));
+ brush47rvc = gameState->assets.at("brush-47").dynamicCast<RailVehicleClass>();
std::random_device randomdev {};
std::uniform_real_distribution<Angle> rotationDistribution {0, two_pi};
std::uniform_int_distribution<GlobalDistance> positionOffsetDistribution {-1500, +1500};
@@ -57,9 +57,10 @@ public:
train2->bogies.back().setPosition(train2->bogies.back().position() + train2->location.position());
for (auto x = 40000; x < 100000; x += 5000) {
for (auto y = 65000; y < 125000; y += 5000) {
- gameState->world.create<Plant>(
- std::dynamic_pointer_cast<Foliage>(gameState->assets.at(std::format(
- "Tree-{:#02}-{}", treeDistribution(randomdev), treeVariantDistribution(randomdev)))),
+ gameState->world.create<Plant>(gameState->assets
+ .at(std::format("Tree-{:#02}-{}", treeDistribution(randomdev),
+ treeVariantDistribution(randomdev)))
+ .dynamicCast<Foliage>(),
Location {{x + positionOffsetDistribution(randomdev), y + positionOffsetDistribution(randomdev),
1},
{0, rotationDistribution(randomdev), 0}});
@@ -76,7 +77,7 @@ public:
water.render(shader, frustum);
rail.render(shader, frustum);
std::ranges::for_each(gameState->assets, [&shader, &frustum](const auto & asset) {
- if (const auto renderable = std::dynamic_pointer_cast<const Renderable>(asset.second)) {
+ if (const auto renderable = asset.second.template getAs<const Renderable>()) {
renderable->render(shader, frustum);
}
});
@@ -98,7 +99,7 @@ public:
{
terrain->shadows(shadowMapper, frustum);
std::ranges::for_each(gameState->assets, [&shadowMapper, &frustum](const auto & asset) {
- if (const auto renderable = std::dynamic_pointer_cast<const Renderable>(asset.second)) {
+ if (const auto renderable = asset.second.template getAs<const Renderable>()) {
renderable->shadows(shadowMapper, frustum);
}
});
generated by cgit v1.2.3 (git 2.46.0) at 2025-04-01 23:12:38 +0000