From f6eadb3fc4c44a5b67f15b06177286e9edd84cf6 Mon Sep 17 00:00:00 2001 From: j-kuehn <57101356+j-kuehn@users.noreply.github.com> Date: Thu, 8 Jul 2021 07:57:45 +0200 Subject: [PATCH 01/15] add unit tests for Fallbacks container --- core/test/test_container.cpp | 50 ++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/core/test/test_container.cpp b/core/test/test_container.cpp index 168f5ac03..3b6a9ec4a 100644 --- a/core/test/test_container.cpp +++ b/core/test/test_container.cpp @@ -44,6 +44,7 @@ void append(ContainerBase& c, const std::initializer_list& types) { } } } +constexpr double INF = std::numeric_limits::infinity(); class NamedStage : public GeneratorMockup { @@ -685,3 +686,52 @@ TEST(Fallback, failing) { EXPECT_FALSE(t.plan()); EXPECT_EQ(t.solutions().size(), 0u); } + +TEST(Fallback, ConnectStageInsideFallbacks) { + resetMockupIds(); + Task t; + t.setRobotModel(getModel()); + + t.add(std::make_unique()); + + auto fallbacks = std::make_unique("Fallbacks"); + fallbacks->add(std::make_unique()); + t.add(std::move(fallbacks)); + + t.add(std::make_unique()); + + EXPECT_TRUE(t.plan()); + EXPECT_EQ(t.numSolutions(), 1u); +} + +TEST(Fallback, ComputeFirstSuccessfulStageOnly) { + resetMockupIds(); + Task t; + t.setRobotModel(getModel()); + + t.add(std::make_unique()); + + auto fallbacks = std::make_unique("Fallbacks"); + fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); + fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); + t.add(std::move(fallbacks)); + + EXPECT_TRUE(t.plan()); + EXPECT_EQ(t.numSolutions(), 1u); +} + +TEST(Fallback, ActiveChildReset) { + resetMockupIds(); + Task t; + t.setRobotModel(getModel()); + + t.add(std::make_unique(PredefinedCosts{ { 0.0, INF, 0.0 } })); + + auto fallbacks = std::make_unique("Fallbacks"); + fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); + fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); + t.add(std::move(fallbacks)); + + EXPECT_TRUE(t.plan()); + EXPECT_EQ(t.numSolutions(), 4u); +} From c6cdd1a97098b837d7d031ebbb47e1503145d7f7 Mon Sep 17 00:00:00 2001 From: Robert Haschke Date: Tue, 13 Jul 2021 22:45:30 +0200 Subject: [PATCH 02/15] Fix test Fallback.ActiveChildReset --- core/test/test_container.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/core/test/test_container.cpp b/core/test/test_container.cpp index 3b6a9ec4a..a3968d6fe 100644 --- a/core/test/test_container.cpp +++ b/core/test/test_container.cpp @@ -730,8 +730,10 @@ TEST(Fallback, ActiveChildReset) { auto fallbacks = std::make_unique("Fallbacks"); fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); + auto first = fallbacks->findChild("FWD1"); t.add(std::move(fallbacks)); EXPECT_TRUE(t.plan()); - EXPECT_EQ(t.numSolutions(), 4u); + EXPECT_EQ(t.numSolutions(), 2u); + EXPECT_EQ(first->solutions().size(), 2u); } From 3244ac92b1231e1abf3ea58562647c2a8fcb9b74 Mon Sep 17 00:00:00 2001 From: v4hn Date: Mon, 26 Jul 2021 15:00:58 +0200 Subject: [PATCH 03/15] disable ConnectStageInsideFallbacks This should work, but will require more changes. --- core/test/test_container.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/core/test/test_container.cpp b/core/test/test_container.cpp index a3968d6fe..e71652610 100644 --- a/core/test/test_container.cpp +++ b/core/test/test_container.cpp @@ -687,7 +687,7 @@ TEST(Fallback, failing) { EXPECT_EQ(t.solutions().size(), 0u); } -TEST(Fallback, ConnectStageInsideFallbacks) { +TEST(Fallback, DISABLED_ConnectStageInsideFallbacks) { resetMockupIds(); Task t; t.setRobotModel(getModel()); From 14380c555286360a0c5232b9290082f18c10f760 Mon Sep 17 00:00:00 2001 From: v4hn Date: Sun, 15 Aug 2021 15:03:59 +0200 Subject: [PATCH 04/15] add another test to cover both cases for failing children --- core/test/test_container.cpp | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/core/test/test_container.cpp b/core/test/test_container.cpp index e71652610..0c04f13be 100644 --- a/core/test/test_container.cpp +++ b/core/test/test_container.cpp @@ -671,7 +671,7 @@ TEST(Task, timeout) { EXPECT_EQ(t.solutions().size(), 2u); } -TEST(Fallback, failing) { +TEST(Fallback, failingNoSolutions) { resetMockupIds(); Task t; t.setRobotModel(getModel()); @@ -687,6 +687,22 @@ TEST(Fallback, failing) { EXPECT_EQ(t.solutions().size(), 0u); } +TEST(Fallback, failingWithFailedSolutions) { + resetMockupIds(); + Task t; + t.setRobotModel(getModel()); + + t.add(std::make_unique(PredefinedCosts::single(0.0))); + + auto fallback = std::make_unique("Fallbacks"); + fallback->add(std::make_unique(PredefinedCosts::constant(INF))); + fallback->add(std::make_unique(PredefinedCosts::constant(INF))); + t.add(std::move(fallback)); + + EXPECT_FALSE(t.plan()); + EXPECT_EQ(t.solutions().size(), 0u); +} + TEST(Fallback, DISABLED_ConnectStageInsideFallbacks) { resetMockupIds(); Task t; From 001eadaf3d9f584a19545e2742d768a899cec6e2 Mon Sep 17 00:00:00 2001 From: v4hn Date: Wed, 18 Aug 2021 11:42:49 +0200 Subject: [PATCH 05/15] move fallback to separate test --- core/test/CMakeLists.txt | 3 ++ core/test/test_container.cpp | 84 ----------------------------- core/test/test_fallback.cpp | 101 +++++++++++++++++++++++++++++++++++ 3 files changed, 104 insertions(+), 84 deletions(-) create mode 100644 core/test/test_fallback.cpp diff --git a/core/test/CMakeLists.txt b/core/test/CMakeLists.txt index 3d7777c4a..c7280bc0b 100644 --- a/core/test/CMakeLists.txt +++ b/core/test/CMakeLists.txt @@ -18,6 +18,9 @@ if (CATKIN_ENABLE_TESTING) catkin_add_gtest(${PROJECT_NAME}-test-serial test_serial.cpp) target_link_libraries(${PROJECT_NAME}-test-serial ${PROJECT_NAME} ${PROJECT_NAME}_stages gtest_utils gtest_main) + catkin_add_gtest(${PROJECT_NAME}-test-fallback test_fallback.cpp) + target_link_libraries(${PROJECT_NAME}-test-fallback ${PROJECT_NAME} ${PROJECT_NAME}_stages gtest_utils gtest_main) + catkin_add_gtest(${PROJECT_NAME}-test-properties test_properties.cpp) target_link_libraries(${PROJECT_NAME}-test-properties ${PROJECT_NAME} gtest_main) diff --git a/core/test/test_container.cpp b/core/test/test_container.cpp index 0c04f13be..4eaa143bd 100644 --- a/core/test/test_container.cpp +++ b/core/test/test_container.cpp @@ -44,7 +44,6 @@ void append(ContainerBase& c, const std::initializer_list& types) { } } } -constexpr double INF = std::numeric_limits::infinity(); class NamedStage : public GeneratorMockup { @@ -670,86 +669,3 @@ TEST(Task, timeout) { EXPECT_TRUE(t.plan()); EXPECT_EQ(t.solutions().size(), 2u); } - -TEST(Fallback, failingNoSolutions) { - resetMockupIds(); - Task t; - t.setRobotModel(getModel()); - - t.add(std::make_unique(PredefinedCosts::single(0.0))); - - auto fallback = std::make_unique("Fallbacks"); - fallback->add(std::make_unique(PredefinedCosts::constant(0.0), 0)); - fallback->add(std::make_unique(PredefinedCosts::constant(0.0), 0)); - t.add(std::move(fallback)); - - EXPECT_FALSE(t.plan()); - EXPECT_EQ(t.solutions().size(), 0u); -} - -TEST(Fallback, failingWithFailedSolutions) { - resetMockupIds(); - Task t; - t.setRobotModel(getModel()); - - t.add(std::make_unique(PredefinedCosts::single(0.0))); - - auto fallback = std::make_unique("Fallbacks"); - fallback->add(std::make_unique(PredefinedCosts::constant(INF))); - fallback->add(std::make_unique(PredefinedCosts::constant(INF))); - t.add(std::move(fallback)); - - EXPECT_FALSE(t.plan()); - EXPECT_EQ(t.solutions().size(), 0u); -} - -TEST(Fallback, DISABLED_ConnectStageInsideFallbacks) { - resetMockupIds(); - Task t; - t.setRobotModel(getModel()); - - t.add(std::make_unique()); - - auto fallbacks = std::make_unique("Fallbacks"); - fallbacks->add(std::make_unique()); - t.add(std::move(fallbacks)); - - t.add(std::make_unique()); - - EXPECT_TRUE(t.plan()); - EXPECT_EQ(t.numSolutions(), 1u); -} - -TEST(Fallback, ComputeFirstSuccessfulStageOnly) { - resetMockupIds(); - Task t; - t.setRobotModel(getModel()); - - t.add(std::make_unique()); - - auto fallbacks = std::make_unique("Fallbacks"); - fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); - fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); - t.add(std::move(fallbacks)); - - EXPECT_TRUE(t.plan()); - EXPECT_EQ(t.numSolutions(), 1u); -} - -TEST(Fallback, ActiveChildReset) { - resetMockupIds(); - Task t; - t.setRobotModel(getModel()); - - t.add(std::make_unique(PredefinedCosts{ { 0.0, INF, 0.0 } })); - - auto fallbacks = std::make_unique("Fallbacks"); - fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); - fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); - auto first = fallbacks->findChild("FWD1"); - t.add(std::move(fallbacks)); - - EXPECT_TRUE(t.plan()); - EXPECT_EQ(t.numSolutions(), 2u); - EXPECT_EQ(first->solutions().size(), 2u); -} diff --git a/core/test/test_fallback.cpp b/core/test/test_fallback.cpp new file mode 100644 index 000000000..15e7a0cc9 --- /dev/null +++ b/core/test/test_fallback.cpp @@ -0,0 +1,101 @@ +#include +#include +#include +#include +#include + +#include "stage_mockups.h" +#include "models.h" +#include "gtest_value_printers.h" + +#include +#include +#include +#include + +using namespace moveit::task_constructor; + +constexpr double INF = std::numeric_limits::infinity(); + +TEST(Fallback, failingNoSolutions) { + resetMockupIds(); + Task t; + t.setRobotModel(getModel()); + + t.add(std::make_unique(PredefinedCosts::single(0.0))); + + auto fallback = std::make_unique("Fallbacks"); + fallback->add(std::make_unique(PredefinedCosts::constant(0.0), 0)); + fallback->add(std::make_unique(PredefinedCosts::constant(0.0), 0)); + t.add(std::move(fallback)); + + EXPECT_FALSE(t.plan()); + EXPECT_EQ(t.solutions().size(), 0u); +} + +TEST(Fallback, failingWithFailedSolutions) { + resetMockupIds(); + Task t; + t.setRobotModel(getModel()); + + t.add(std::make_unique(PredefinedCosts::single(0.0))); + + auto fallback = std::make_unique("Fallbacks"); + fallback->add(std::make_unique(PredefinedCosts::constant(INF))); + fallback->add(std::make_unique(PredefinedCosts::constant(INF))); + t.add(std::move(fallback)); + + EXPECT_FALSE(t.plan()); + EXPECT_EQ(t.solutions().size(), 0u); +} + +TEST(Fallback, DISABLED_ConnectStageInsideFallbacks) { + resetMockupIds(); + Task t; + t.setRobotModel(getModel()); + + t.add(std::make_unique()); + + auto fallbacks = std::make_unique("Fallbacks"); + fallbacks->add(std::make_unique()); + t.add(std::move(fallbacks)); + + t.add(std::make_unique()); + + EXPECT_TRUE(t.plan()); + EXPECT_EQ(t.numSolutions(), 1u); +} + +TEST(Fallback, ComputeFirstSuccessfulStageOnly) { + resetMockupIds(); + Task t; + t.setRobotModel(getModel()); + + t.add(std::make_unique()); + + auto fallbacks = std::make_unique("Fallbacks"); + fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); + fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); + t.add(std::move(fallbacks)); + + EXPECT_TRUE(t.plan()); + EXPECT_EQ(t.numSolutions(), 1u); +} + +TEST(Fallback, ActiveChildReset) { + resetMockupIds(); + Task t; + t.setRobotModel(getModel()); + + t.add(std::make_unique(PredefinedCosts{ { 0.0, INF, 0.0 } })); + + auto fallbacks = std::make_unique("Fallbacks"); + fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); + fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); + auto first = fallbacks->findChild("FWD1"); + t.add(std::move(fallbacks)); + + EXPECT_TRUE(t.plan()); + EXPECT_EQ(t.numSolutions(), 2u); + EXPECT_EQ(first->solutions().size(), 2u); +} From 5d9efc3b2bf686da975d0014d93d6306f9f0705a Mon Sep 17 00:00:00 2001 From: v4hn Date: Wed, 18 Aug 2021 12:21:12 +0200 Subject: [PATCH 06/15] fallback tests: use fixture --- core/test/test_fallback.cpp | 37 ++++++++++++++----------------------- 1 file changed, 14 insertions(+), 23 deletions(-) diff --git a/core/test/test_fallback.cpp b/core/test/test_fallback.cpp index 15e7a0cc9..43470e57a 100644 --- a/core/test/test_fallback.cpp +++ b/core/test/test_fallback.cpp @@ -17,11 +17,18 @@ using namespace moveit::task_constructor; constexpr double INF = std::numeric_limits::infinity(); -TEST(Fallback, failingNoSolutions) { - resetMockupIds(); +struct TestBase : public testing::Test +{ Task t; - t.setRobotModel(getModel()); + TestBase() { + resetMockupIds(); + t.setRobotModel(getModel()); + } +}; +using FallbacksFixture = TestBase; + +TEST_F(FallbacksFixture, failingNoSolutions) { t.add(std::make_unique(PredefinedCosts::single(0.0))); auto fallback = std::make_unique("Fallbacks"); @@ -33,11 +40,7 @@ TEST(Fallback, failingNoSolutions) { EXPECT_EQ(t.solutions().size(), 0u); } -TEST(Fallback, failingWithFailedSolutions) { - resetMockupIds(); - Task t; - t.setRobotModel(getModel()); - +TEST_F(FallbacksFixture, failingWithFailedSolutions) { t.add(std::make_unique(PredefinedCosts::single(0.0))); auto fallback = std::make_unique("Fallbacks"); @@ -49,11 +52,7 @@ TEST(Fallback, failingWithFailedSolutions) { EXPECT_EQ(t.solutions().size(), 0u); } -TEST(Fallback, DISABLED_ConnectStageInsideFallbacks) { - resetMockupIds(); - Task t; - t.setRobotModel(getModel()); - +TEST_F(FallbacksFixture, DISABLED_ConnectStageInsideFallbacks) { t.add(std::make_unique()); auto fallbacks = std::make_unique("Fallbacks"); @@ -66,11 +65,7 @@ TEST(Fallback, DISABLED_ConnectStageInsideFallbacks) { EXPECT_EQ(t.numSolutions(), 1u); } -TEST(Fallback, ComputeFirstSuccessfulStageOnly) { - resetMockupIds(); - Task t; - t.setRobotModel(getModel()); - +TEST_F(FallbacksFixture, ComputeFirstSuccessfulStageOnly) { t.add(std::make_unique()); auto fallbacks = std::make_unique("Fallbacks"); @@ -82,11 +77,7 @@ TEST(Fallback, ComputeFirstSuccessfulStageOnly) { EXPECT_EQ(t.numSolutions(), 1u); } -TEST(Fallback, ActiveChildReset) { - resetMockupIds(); - Task t; - t.setRobotModel(getModel()); - +TEST_F(FallbacksFixture, ActiveChildReset) { t.add(std::make_unique(PredefinedCosts{ { 0.0, INF, 0.0 } })); auto fallbacks = std::make_unique("Fallbacks"); From 2bee9d5f6603a866edaa4cb619dc3a3974c6629c Mon Sep 17 00:00:00 2001 From: v4hn Date: Wed, 18 Aug 2021 12:39:46 +0200 Subject: [PATCH 07/15] rearrange fallback test fixtures --- core/test/stage_mockups.h | 17 +++++++++++++- core/test/test_fallback.cpp | 47 ++++++++++++++++--------------------- 2 files changed, 36 insertions(+), 28 deletions(-) diff --git a/core/test/stage_mockups.h b/core/test/stage_mockups.h index fdab8afaa..613f32223 100644 --- a/core/test/stage_mockups.h +++ b/core/test/stage_mockups.h @@ -1,8 +1,13 @@ #pragma once -#include +#include + #include +#include "models.h" + +#include + namespace moveit { namespace task_constructor { @@ -113,5 +118,15 @@ struct BackwardMockup : public PropagatorMockup // reset ids of all Mockup types (used to generate unique stage names) void resetMockupIds(); +// provide a basic test fixture that prepares a Task +struct TaskTestBase : public testing::Test +{ + Task t; + TaskTestBase() { + resetMockupIds(); + t.setRobotModel(getModel()); + } +}; + } // namespace task_constructor } // namespace moveit diff --git a/core/test/test_fallback.cpp b/core/test/test_fallback.cpp index 43470e57a..19a6839c1 100644 --- a/core/test/test_fallback.cpp +++ b/core/test/test_fallback.cpp @@ -17,18 +17,9 @@ using namespace moveit::task_constructor; constexpr double INF = std::numeric_limits::infinity(); -struct TestBase : public testing::Test -{ - Task t; - TestBase() { - resetMockupIds(); - t.setRobotModel(getModel()); - } -}; - -using FallbacksFixture = TestBase; - -TEST_F(FallbacksFixture, failingNoSolutions) { +using FallbacksFixturePropagate = TaskTestBase; + +TEST_F(FallbacksFixturePropagate, failingNoSolutions) { t.add(std::make_unique(PredefinedCosts::single(0.0))); auto fallback = std::make_unique("Fallbacks"); @@ -40,7 +31,7 @@ TEST_F(FallbacksFixture, failingNoSolutions) { EXPECT_EQ(t.solutions().size(), 0u); } -TEST_F(FallbacksFixture, failingWithFailedSolutions) { +TEST_F(FallbacksFixturePropagate, failingWithFailedSolutions) { t.add(std::make_unique(PredefinedCosts::single(0.0))); auto fallback = std::make_unique("Fallbacks"); @@ -52,41 +43,43 @@ TEST_F(FallbacksFixture, failingWithFailedSolutions) { EXPECT_EQ(t.solutions().size(), 0u); } -TEST_F(FallbacksFixture, DISABLED_ConnectStageInsideFallbacks) { +TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStageOnly) { t.add(std::make_unique()); auto fallbacks = std::make_unique("Fallbacks"); - fallbacks->add(std::make_unique()); + fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); + fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); t.add(std::move(fallbacks)); - t.add(std::make_unique()); - EXPECT_TRUE(t.plan()); EXPECT_EQ(t.numSolutions(), 1u); } -TEST_F(FallbacksFixture, ComputeFirstSuccessfulStageOnly) { - t.add(std::make_unique()); +TEST_F(FallbacksFixturePropagate, ActiveChildReset) { + t.add(std::make_unique(PredefinedCosts{ { 0.0, INF, 0.0 } })); auto fallbacks = std::make_unique("Fallbacks"); fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); + auto first = fallbacks->findChild("FWD1"); t.add(std::move(fallbacks)); EXPECT_TRUE(t.plan()); - EXPECT_EQ(t.numSolutions(), 1u); + EXPECT_EQ(t.numSolutions(), 2u); + EXPECT_EQ(first->solutions().size(), 2u); } -TEST_F(FallbacksFixture, ActiveChildReset) { - t.add(std::make_unique(PredefinedCosts{ { 0.0, INF, 0.0 } })); +using FallbacksFixtureConnect = TaskTestBase; + +TEST_F(FallbacksFixtureConnect, DISABLED_ConnectStageInsideFallbacks) { + t.add(std::make_unique()); auto fallbacks = std::make_unique("Fallbacks"); - fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); - fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); - auto first = fallbacks->findChild("FWD1"); + fallbacks->add(std::make_unique()); t.add(std::move(fallbacks)); + t.add(std::make_unique()); + EXPECT_TRUE(t.plan()); - EXPECT_EQ(t.numSolutions(), 2u); - EXPECT_EQ(first->solutions().size(), 2u); + EXPECT_EQ(t.numSolutions(), 1u); } From f75a498f55977767847afcee2be0fb35bbdd7775 Mon Sep 17 00:00:00 2001 From: v4hn Date: Wed, 18 Aug 2021 12:40:27 +0200 Subject: [PATCH 08/15] fallbacks: add a test to use fallbacks *per state* The current implementation will not fall back for each state independently, but is meant to stay with the first child producing a solution. For propagators, this is problematic though as the picked child depends on the (arbitrary) first received state. Instead, fallbacks should pass each state to each child separately until one produces a solution for it (or all are exhausted). --- core/test/test_fallback.cpp | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/core/test/test_fallback.cpp b/core/test/test_fallback.cpp index 19a6839c1..42e16594e 100644 --- a/core/test/test_fallback.cpp +++ b/core/test/test_fallback.cpp @@ -55,6 +55,24 @@ TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStageOnly) { EXPECT_EQ(t.numSolutions(), 1u); } +TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStagePerSolutionOnly) { + t.add(std::make_unique(std::list{ 0.0, 1.0 })); + + auto fallbacks = std::make_unique("Fallbacks"); + fallbacks->add(std::make_unique(std::list{ INF, 0.0 })); + fallbacks->add(std::make_unique(std::list{ 0.0, INF })); + auto fwd1 = fallbacks->findChild("FWD1"); + auto fwd2 = fallbacks->findChild("FWD2"); + t.add(std::move(fallbacks)); + + EXPECT_TRUE(t.plan()); + EXPECT_EQ(t.numSolutions(), 2u); + ASSERT_EQ(fwd1->solutions().size(), 1u); + EXPECT_EQ(fwd1->solutions().front()->cost(), 1.0); + ASSERT_EQ(fwd2->solutions().size(), 1u); + EXPECT_EQ(fwd2->solutions().front()->cost(), 0.0); +} + TEST_F(FallbacksFixturePropagate, ActiveChildReset) { t.add(std::make_unique(PredefinedCosts{ { 0.0, INF, 0.0 } })); From b61e045f2c1782fe499aad1c4ec56cfedeb9fdcf Mon Sep 17 00:00:00 2001 From: v4hn Date: Wed, 18 Aug 2021 12:58:28 +0200 Subject: [PATCH 09/15] add a test for generator-fallbacks --- core/test/test_fallback.cpp | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/core/test/test_fallback.cpp b/core/test/test_fallback.cpp index 42e16594e..ceb687153 100644 --- a/core/test/test_fallback.cpp +++ b/core/test/test_fallback.cpp @@ -17,6 +17,20 @@ using namespace moveit::task_constructor; constexpr double INF = std::numeric_limits::infinity(); +using FallbacksFixtureGenerator = TaskTestBase; + +TEST_F(FallbacksFixtureGenerator, stayWithFirstSuccessful) { + auto fallback = std::make_unique("Fallbacks"); + fallback->add(std::make_unique(PredefinedCosts::single(INF))); + fallback->add(std::make_unique(PredefinedCosts::single(1.0))); + fallback->add(std::make_unique(PredefinedCosts::single(2.0))); + t.add(std::move(fallback)); + + EXPECT_TRUE(t.plan()); + ASSERT_EQ(t.solutions().size(), 1u); + EXPECT_EQ(t.solutions().front()->cost(), 1.0); +} + using FallbacksFixturePropagate = TaskTestBase; TEST_F(FallbacksFixturePropagate, failingNoSolutions) { @@ -89,7 +103,7 @@ TEST_F(FallbacksFixturePropagate, ActiveChildReset) { using FallbacksFixtureConnect = TaskTestBase; -TEST_F(FallbacksFixtureConnect, DISABLED_ConnectStageInsideFallbacks) { +TEST_F(FallbacksFixtureConnect, ConnectStageInsideFallbacks) { t.add(std::make_unique()); auto fallbacks = std::make_unique("Fallbacks"); From a582fe8297c601b022640b673487b1094a8b8d4d Mon Sep 17 00:00:00 2001 From: v4hn Date: Wed, 18 Aug 2021 13:25:51 +0200 Subject: [PATCH 10/15] add another non-trivial test for a reliable fallbacks container --- core/test/test_fallback.cpp | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/core/test/test_fallback.cpp b/core/test/test_fallback.cpp index ceb687153..bae981b30 100644 --- a/core/test/test_fallback.cpp +++ b/core/test/test_fallback.cpp @@ -57,6 +57,19 @@ TEST_F(FallbacksFixturePropagate, failingWithFailedSolutions) { EXPECT_EQ(t.solutions().size(), 0u); } +TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions) { + t.add(std::make_unique()); + + auto fallback = std::make_unique("Fallbacks"); + fallback->add(std::make_unique(std::list{ INF, 1.0 }, 2)); + fallback->add(std::make_unique(PredefinedCosts::single(2.0))); + t.add(std::move(fallback)); + + EXPECT_TRUE(t.plan()); + ASSERT_EQ(t.solutions().size(), 1u); + EXPECT_EQ(t.solutions().front()->cost(), 1.0); +} + TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStageOnly) { t.add(std::make_unique()); From 61399d6d2384b42a8bbcd280b710884643444f0a Mon Sep 17 00:00:00 2001 From: v4hn Date: Mon, 20 Sep 2021 14:49:01 +0200 Subject: [PATCH 11/15] fixup & extend fallback tests --- core/test/test_fallback.cpp | 43 ++++++++++++++++++++++++------------- 1 file changed, 28 insertions(+), 15 deletions(-) diff --git a/core/test/test_fallback.cpp b/core/test/test_fallback.cpp index bae981b30..f71fa9b35 100644 --- a/core/test/test_fallback.cpp +++ b/core/test/test_fallback.cpp @@ -57,19 +57,6 @@ TEST_F(FallbacksFixturePropagate, failingWithFailedSolutions) { EXPECT_EQ(t.solutions().size(), 0u); } -TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions) { - t.add(std::make_unique()); - - auto fallback = std::make_unique("Fallbacks"); - fallback->add(std::make_unique(std::list{ INF, 1.0 }, 2)); - fallback->add(std::make_unique(PredefinedCosts::single(2.0))); - t.add(std::move(fallback)); - - EXPECT_TRUE(t.plan()); - ASSERT_EQ(t.solutions().size(), 1u); - EXPECT_EQ(t.solutions().front()->cost(), 1.0); -} - TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStageOnly) { t.add(std::make_unique()); @@ -95,9 +82,35 @@ TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStagePerSolutionOnly) { EXPECT_TRUE(t.plan()); EXPECT_EQ(t.numSolutions(), 2u); ASSERT_EQ(fwd1->solutions().size(), 1u); - EXPECT_EQ(fwd1->solutions().front()->cost(), 1.0); + EXPECT_EQ(fwd1->solutions().front()->start()->priority().cost(), 1.0); ASSERT_EQ(fwd2->solutions().size(), 1u); - EXPECT_EQ(fwd2->solutions().front()->cost(), 0.0); + EXPECT_EQ(fwd2->solutions().front()->start()->priority().cost(), 0.0); +} + +TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions) { + t.add(std::make_unique()); + + auto fallback = std::make_unique("Fallbacks"); + fallback->add(std::make_unique(std::list{ INF, 1.0 }, 2)); + fallback->add(std::make_unique(PredefinedCosts::single(2.0))); + t.add(std::move(fallback)); + + EXPECT_TRUE(t.plan()); + ASSERT_EQ(t.solutions().size(), 1u); + EXPECT_EQ(t.solutions().front()->cost(), 1.0); +} + +TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions2) { + t.add(std::make_unique()); + + auto fallback = std::make_unique("Fallbacks"); + fallback->add(std::make_unique(std::list{ 1.0, INF }, 2)); + fallback->add(std::make_unique(PredefinedCosts::single(2.0))); + t.add(std::move(fallback)); + + EXPECT_TRUE(t.plan()); + ASSERT_EQ(t.solutions().size(), 1u); + EXPECT_EQ(t.solutions().front()->cost(), 1.0); } TEST_F(FallbacksFixturePropagate, ActiveChildReset) { From 61496fecd3cb1656bb530f169a06eea6d30ae822 Mon Sep 17 00:00:00 2001 From: Robert Haschke Date: Thu, 2 Sep 2021 12:13:40 +0200 Subject: [PATCH 12/15] Simplify tests by introducing EXPECT_COSTS() --- core/test/CMakeLists.txt | 4 ++-- core/test/stage_mockups.h | 9 +++++++++ core/test/test_fallback.cpp | 34 ++++++++++++++++------------------ 3 files changed, 27 insertions(+), 20 deletions(-) diff --git a/core/test/CMakeLists.txt b/core/test/CMakeLists.txt index c7280bc0b..a05f62049 100644 --- a/core/test/CMakeLists.txt +++ b/core/test/CMakeLists.txt @@ -18,7 +18,7 @@ if (CATKIN_ENABLE_TESTING) catkin_add_gtest(${PROJECT_NAME}-test-serial test_serial.cpp) target_link_libraries(${PROJECT_NAME}-test-serial ${PROJECT_NAME} ${PROJECT_NAME}_stages gtest_utils gtest_main) - catkin_add_gtest(${PROJECT_NAME}-test-fallback test_fallback.cpp) + catkin_add_gmock(${PROJECT_NAME}-test-fallback test_fallback.cpp) target_link_libraries(${PROJECT_NAME}-test-fallback ${PROJECT_NAME} ${PROJECT_NAME}_stages gtest_utils gtest_main) catkin_add_gtest(${PROJECT_NAME}-test-properties test_properties.cpp) @@ -27,7 +27,7 @@ if (CATKIN_ENABLE_TESTING) catkin_add_gmock(${PROJECT_NAME}-test-cost_queue test_cost_queue.cpp) target_link_libraries(${PROJECT_NAME}-test-cost_queue ${PROJECT_NAME} gtest_main) - catkin_add_gtest(${PROJECT_NAME}-test-interface_state test_interface_state.cpp) + catkin_add_gmock(${PROJECT_NAME}-test-interface_state test_interface_state.cpp) target_link_libraries(${PROJECT_NAME}-test-interface_state ${PROJECT_NAME} gtest_utils gtest_main) catkin_add_gtest(${PROJECT_NAME}-test-cost_terms test_cost_terms.cpp) diff --git a/core/test/stage_mockups.h b/core/test/stage_mockups.h index 613f32223..2e517a3b8 100644 --- a/core/test/stage_mockups.h +++ b/core/test/stage_mockups.h @@ -7,6 +7,7 @@ #include "models.h" #include +#include namespace moveit { namespace task_constructor { @@ -128,5 +129,13 @@ struct TaskTestBase : public testing::Test } }; +#define EXPECT_COSTS(value, matcher) \ + { \ + std ::vector costs; \ + std::transform(value.begin(), value.end(), std::back_inserter(costs), \ + [](const SolutionBaseConstPtr& s) { return s->cost(); }); \ + EXPECT_THAT(costs, matcher); \ + } + } // namespace task_constructor } // namespace moveit diff --git a/core/test/test_fallback.cpp b/core/test/test_fallback.cpp index f71fa9b35..a589443ec 100644 --- a/core/test/test_fallback.cpp +++ b/core/test/test_fallback.cpp @@ -70,21 +70,19 @@ TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStageOnly) { } TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStagePerSolutionOnly) { - t.add(std::make_unique(std::list{ 0.0, 1.0 })); + t.add(std::make_unique(std::list{ 1.0, 2.0 })); auto fallbacks = std::make_unique("Fallbacks"); - fallbacks->add(std::make_unique(std::list{ INF, 0.0 })); - fallbacks->add(std::make_unique(std::list{ 0.0, INF })); + fallbacks->add(std::make_unique(std::list{ INF, 10.0 })); + fallbacks->add(std::make_unique(std::list{ 20.0, INF })); auto fwd1 = fallbacks->findChild("FWD1"); auto fwd2 = fallbacks->findChild("FWD2"); t.add(std::move(fallbacks)); EXPECT_TRUE(t.plan()); - EXPECT_EQ(t.numSolutions(), 2u); - ASSERT_EQ(fwd1->solutions().size(), 1u); - EXPECT_EQ(fwd1->solutions().front()->start()->priority().cost(), 1.0); - ASSERT_EQ(fwd2->solutions().size(), 1u); - EXPECT_EQ(fwd2->solutions().front()->start()->priority().cost(), 0.0); + EXPECT_COSTS(t.solutions(), testing::ElementsAre(12, 21)); + EXPECT_EQ(fwd1->solutions().size(), 1u); + EXPECT_EQ(fwd2->solutions().size(), 1u); } TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions) { @@ -96,8 +94,7 @@ TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions) { t.add(std::move(fallback)); EXPECT_TRUE(t.plan()); - ASSERT_EQ(t.solutions().size(), 1u); - EXPECT_EQ(t.solutions().front()->cost(), 1.0); + EXPECT_COSTS(t.solutions(), testing::ElementsAre(1.0)); } TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions2) { @@ -109,22 +106,23 @@ TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions2) { t.add(std::move(fallback)); EXPECT_TRUE(t.plan()); - ASSERT_EQ(t.solutions().size(), 1u); - EXPECT_EQ(t.solutions().front()->cost(), 1.0); + EXPECT_COSTS(t.solutions(), testing::ElementsAre(1.0)); } TEST_F(FallbacksFixturePropagate, ActiveChildReset) { - t.add(std::make_unique(PredefinedCosts{ { 0.0, INF, 0.0 } })); + t.add(std::make_unique(PredefinedCosts{ { 1.0, INF, 3.0 } })); auto fallbacks = std::make_unique("Fallbacks"); - fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); - fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); - auto first = fallbacks->findChild("FWD1"); + fallbacks->add(std::make_unique(PredefinedCosts::constant(10.0))); + fallbacks->add(std::make_unique(PredefinedCosts::constant(20.0))); + auto fwd1 = fallbacks->findChild("FWD1"); + auto fwd2 = fallbacks->findChild("FWD2"); t.add(std::move(fallbacks)); EXPECT_TRUE(t.plan()); - EXPECT_EQ(t.numSolutions(), 2u); - EXPECT_EQ(first->solutions().size(), 2u); + EXPECT_COSTS(t.solutions(), testing::ElementsAre(11, 13)); + EXPECT_COSTS(fwd1->solutions(), testing::ElementsAre(10, 10)); + EXPECT_COSTS(fwd2->solutions(), testing::IsEmpty()); } using FallbacksFixtureConnect = TaskTestBase; From 4e0f295d1e1680b625ffdc2d37727c5d46b3fd2d Mon Sep 17 00:00:00 2001 From: Robert Haschke Date: Thu, 2 Sep 2021 12:17:04 +0200 Subject: [PATCH 13/15] Replace std::list() with PredefinedCosts() --- core/test/test_fallback.cpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/core/test/test_fallback.cpp b/core/test/test_fallback.cpp index a589443ec..b34193bbc 100644 --- a/core/test/test_fallback.cpp +++ b/core/test/test_fallback.cpp @@ -37,8 +37,8 @@ TEST_F(FallbacksFixturePropagate, failingNoSolutions) { t.add(std::make_unique(PredefinedCosts::single(0.0))); auto fallback = std::make_unique("Fallbacks"); - fallback->add(std::make_unique(PredefinedCosts::constant(0.0), 0)); - fallback->add(std::make_unique(PredefinedCosts::constant(0.0), 0)); + fallback->add(std::make_unique(PredefinedCosts({}), 0)); + fallback->add(std::make_unique(PredefinedCosts({}), 0)); t.add(std::move(fallback)); EXPECT_FALSE(t.plan()); @@ -70,11 +70,11 @@ TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStageOnly) { } TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStagePerSolutionOnly) { - t.add(std::make_unique(std::list{ 1.0, 2.0 })); + t.add(std::make_unique(PredefinedCosts({ 1.0, 2.0 }))); auto fallbacks = std::make_unique("Fallbacks"); - fallbacks->add(std::make_unique(std::list{ INF, 10.0 })); - fallbacks->add(std::make_unique(std::list{ 20.0, INF })); + fallbacks->add(std::make_unique(PredefinedCosts({ INF, 10.0 }))); + fallbacks->add(std::make_unique(PredefinedCosts({ 20.0, INF }))); auto fwd1 = fallbacks->findChild("FWD1"); auto fwd2 = fallbacks->findChild("FWD2"); t.add(std::move(fallbacks)); @@ -89,7 +89,7 @@ TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions) { t.add(std::make_unique()); auto fallback = std::make_unique("Fallbacks"); - fallback->add(std::make_unique(std::list{ INF, 1.0 }, 2)); + fallback->add(std::make_unique(PredefinedCosts({ INF, 1.0 }), 2)); fallback->add(std::make_unique(PredefinedCosts::single(2.0))); t.add(std::move(fallback)); @@ -101,7 +101,7 @@ TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions2) { t.add(std::make_unique()); auto fallback = std::make_unique("Fallbacks"); - fallback->add(std::make_unique(std::list{ 1.0, INF }, 2)); + fallback->add(std::make_unique(PredefinedCosts({ 1.0, INF }), 2)); fallback->add(std::make_unique(PredefinedCosts::single(2.0))); t.add(std::move(fallback)); @@ -110,7 +110,7 @@ TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions2) { } TEST_F(FallbacksFixturePropagate, ActiveChildReset) { - t.add(std::make_unique(PredefinedCosts{ { 1.0, INF, 3.0 } })); + t.add(std::make_unique(PredefinedCosts({ 1.0, INF, 3.0 }))); auto fallbacks = std::make_unique("Fallbacks"); fallbacks->add(std::make_unique(PredefinedCosts::constant(10.0))); From 35dc03736509ec0c2f94ed2742024df6821b03b4 Mon Sep 17 00:00:00 2001 From: Robert Haschke Date: Thu, 16 Sep 2021 21:45:52 +0200 Subject: [PATCH 14/15] Add more fallback tests --- core/test/test_fallback.cpp | 70 +++++++++++++++++++++++++++++++------ 1 file changed, 59 insertions(+), 11 deletions(-) diff --git a/core/test/test_fallback.cpp b/core/test/test_fallback.cpp index b34193bbc..0e0195e90 100644 --- a/core/test/test_fallback.cpp +++ b/core/test/test_fallback.cpp @@ -70,19 +70,53 @@ TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStageOnly) { } TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStagePerSolutionOnly) { + t.add(std::make_unique(PredefinedCosts({ 2.0, 1.0 }))); + // duplicate generator solutions with resulting costs: 4, 2 | 3, 1 + t.add(std::make_unique(PredefinedCosts({ 2.0, 0.0, 2.0, 0.0 }), 2)); + + auto fallbacks = std::make_unique("Fallbacks"); + fallbacks->add(std::make_unique(PredefinedCosts({ INF, INF, 110.0, 120.0 }))); + fallbacks->add(std::make_unique(PredefinedCosts({ 210.0, 220.0, 0, 0 }))); + t.add(std::move(fallbacks)); + + EXPECT_TRUE(t.plan()); + EXPECT_COSTS(t.solutions(), testing::ElementsAre(113, 124, 211, 222)); +} + +TEST_F(FallbacksFixturePropagate, UpdateSolutionOrder) { + t.add(std::make_unique(PredefinedCosts({ 10.0, 0.0 }))); t.add(std::make_unique(PredefinedCosts({ 1.0, 2.0 }))); + // available solutions (sorted) in individual runs of fallbacks: 1 | 11, 2 | 2, 11 + + // use a fallback container to delay computation twice: only the last child succeeds + auto inner = std::make_unique("Inner"); + inner->add(std::make_unique(PredefinedCosts({ INF }, false))); + inner->add(std::make_unique(PredefinedCosts({ INF }, false))); + inner->add(std::make_unique(PredefinedCosts::constant(0.0))); auto fallbacks = std::make_unique("Fallbacks"); - fallbacks->add(std::make_unique(PredefinedCosts({ INF, 10.0 }))); - fallbacks->add(std::make_unique(PredefinedCosts({ 20.0, INF }))); - auto fwd1 = fallbacks->findChild("FWD1"); - auto fwd2 = fallbacks->findChild("FWD2"); + fallbacks->add(std::move(inner)); + t.add(std::move(fallbacks)); + + EXPECT_TRUE(t.plan(1)); // only return 1st solution + EXPECT_COSTS(t.solutions(), testing::ElementsAre(2)); // expecting less costly solution as result +} + +TEST_F(FallbacksFixturePropagate, MultipleActivePendingStates) { + t.add(std::make_unique(PredefinedCosts({ 2.0, 1.0, 3.0 }))); + // use a fallback container to delay computation: the 1st child never succeeds, but only the 2nd + auto inner = std::make_unique("Inner"); + inner->add(std::make_unique(PredefinedCosts({ INF }, false))); // always fail + inner->add(std::make_unique(PredefinedCosts({ 10.0, INF, 30.0 }))); + + auto fallbacks = std::make_unique("Fallbacks"); + fallbacks->add(std::move(inner)); + fallbacks->add(std::make_unique(PredefinedCosts({ INF }))); t.add(std::move(fallbacks)); EXPECT_TRUE(t.plan()); - EXPECT_COSTS(t.solutions(), testing::ElementsAre(12, 21)); - EXPECT_EQ(fwd1->solutions().size(), 1u); - EXPECT_EQ(fwd2->solutions().size(), 1u); + EXPECT_COSTS(t.solutions(), testing::ElementsAre(11, 33)); + // check that first solution is not marked as pruned } TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions) { @@ -128,14 +162,28 @@ TEST_F(FallbacksFixturePropagate, ActiveChildReset) { using FallbacksFixtureConnect = TaskTestBase; TEST_F(FallbacksFixtureConnect, ConnectStageInsideFallbacks) { - t.add(std::make_unique()); + t.add(std::make_unique(PredefinedCosts({ 1.0, 2.0 }))); auto fallbacks = std::make_unique("Fallbacks"); - fallbacks->add(std::make_unique()); + fallbacks->add(std::make_unique(PredefinedCosts::constant(0.0))); + fallbacks->add(std::make_unique(PredefinedCosts::constant(100.0))); t.add(std::move(fallbacks)); - t.add(std::make_unique()); + t.add(std::make_unique(PredefinedCosts({ 10.0, 20.0 }))); EXPECT_TRUE(t.plan()); - EXPECT_EQ(t.numSolutions(), 1u); + EXPECT_COSTS(t.solutions(), testing::ElementsAre(11, 12, 21, 22)); +} + +int main(int argc, char** argv) { + for (int i = 1; i < argc; ++i) { + if (strcmp(argv[i], "--debug") == 0) { + if (ros::console::set_logger_level(ROSCONSOLE_DEFAULT_NAME, ros::console::levels::Debug)) + ros::console::notifyLoggerLevelsChanged(); + break; + } + } + + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } From dbfa7e2b8a79ad85f4df77b2ae6548690f40d79c Mon Sep 17 00:00:00 2001 From: v4hn Date: Mon, 20 Sep 2021 15:11:13 +0200 Subject: [PATCH 15/15] disable currently failing tests They will be enabled when the corresponding functionality is merged. --- core/test/test_fallback.cpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/core/test/test_fallback.cpp b/core/test/test_fallback.cpp index 0e0195e90..e721604ce 100644 --- a/core/test/test_fallback.cpp +++ b/core/test/test_fallback.cpp @@ -19,7 +19,7 @@ constexpr double INF = std::numeric_limits::infinity(); using FallbacksFixtureGenerator = TaskTestBase; -TEST_F(FallbacksFixtureGenerator, stayWithFirstSuccessful) { +TEST_F(FallbacksFixtureGenerator, DISABLED_stayWithFirstSuccessful) { auto fallback = std::make_unique("Fallbacks"); fallback->add(std::make_unique(PredefinedCosts::single(INF))); fallback->add(std::make_unique(PredefinedCosts::single(1.0))); @@ -57,7 +57,7 @@ TEST_F(FallbacksFixturePropagate, failingWithFailedSolutions) { EXPECT_EQ(t.solutions().size(), 0u); } -TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStageOnly) { +TEST_F(FallbacksFixturePropagate, DISABLED_ComputeFirstSuccessfulStageOnly) { t.add(std::make_unique()); auto fallbacks = std::make_unique("Fallbacks"); @@ -69,7 +69,7 @@ TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStageOnly) { EXPECT_EQ(t.numSolutions(), 1u); } -TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStagePerSolutionOnly) { +TEST_F(FallbacksFixturePropagate, DISABLED_ComputeFirstSuccessfulStagePerSolutionOnly) { t.add(std::make_unique(PredefinedCosts({ 2.0, 1.0 }))); // duplicate generator solutions with resulting costs: 4, 2 | 3, 1 t.add(std::make_unique(PredefinedCosts({ 2.0, 0.0, 2.0, 0.0 }), 2)); @@ -83,7 +83,7 @@ TEST_F(FallbacksFixturePropagate, ComputeFirstSuccessfulStagePerSolutionOnly) { EXPECT_COSTS(t.solutions(), testing::ElementsAre(113, 124, 211, 222)); } -TEST_F(FallbacksFixturePropagate, UpdateSolutionOrder) { +TEST_F(FallbacksFixturePropagate, DISABLED_UpdateSolutionOrder) { t.add(std::make_unique(PredefinedCosts({ 10.0, 0.0 }))); t.add(std::make_unique(PredefinedCosts({ 1.0, 2.0 }))); // available solutions (sorted) in individual runs of fallbacks: 1 | 11, 2 | 2, 11 @@ -102,7 +102,7 @@ TEST_F(FallbacksFixturePropagate, UpdateSolutionOrder) { EXPECT_COSTS(t.solutions(), testing::ElementsAre(2)); // expecting less costly solution as result } -TEST_F(FallbacksFixturePropagate, MultipleActivePendingStates) { +TEST_F(FallbacksFixturePropagate, DISABLED_MultipleActivePendingStates) { t.add(std::make_unique(PredefinedCosts({ 2.0, 1.0, 3.0 }))); // use a fallback container to delay computation: the 1st child never succeeds, but only the 2nd auto inner = std::make_unique("Inner"); @@ -119,7 +119,7 @@ TEST_F(FallbacksFixturePropagate, MultipleActivePendingStates) { // check that first solution is not marked as pruned } -TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions) { +TEST_F(FallbacksFixturePropagate, DISABLED_successfulWithMixedSolutions) { t.add(std::make_unique()); auto fallback = std::make_unique("Fallbacks"); @@ -131,7 +131,7 @@ TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions) { EXPECT_COSTS(t.solutions(), testing::ElementsAre(1.0)); } -TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions2) { +TEST_F(FallbacksFixturePropagate, DISABLED_successfulWithMixedSolutions2) { t.add(std::make_unique()); auto fallback = std::make_unique("Fallbacks"); @@ -143,7 +143,7 @@ TEST_F(FallbacksFixturePropagate, successfulWithMixedSolutions2) { EXPECT_COSTS(t.solutions(), testing::ElementsAre(1.0)); } -TEST_F(FallbacksFixturePropagate, ActiveChildReset) { +TEST_F(FallbacksFixturePropagate, DISABLED_ActiveChildReset) { t.add(std::make_unique(PredefinedCosts({ 1.0, INF, 3.0 }))); auto fallbacks = std::make_unique("Fallbacks"); @@ -161,7 +161,7 @@ TEST_F(FallbacksFixturePropagate, ActiveChildReset) { using FallbacksFixtureConnect = TaskTestBase; -TEST_F(FallbacksFixtureConnect, ConnectStageInsideFallbacks) { +TEST_F(FallbacksFixtureConnect, DISABLED_ConnectStageInsideFallbacks) { t.add(std::make_unique(PredefinedCosts({ 1.0, 2.0 }))); auto fallbacks = std::make_unique("Fallbacks");