From 204725ea21f601ccaaeba8fe256b319c3725683e Mon Sep 17 00:00:00 2001 From: Maxwell Pirtle Date: Fri, 17 Mar 2023 15:11:48 +0100 Subject: [PATCH] Add dependency between same actor for tests It doesn't make sense to say that two transitions executed by the same actor are independent; indeed, it would lead to unexpected results when testing whether or not a configuration were properly tracking the "most recent" event for each actor, as is done in subsequent commits --- src/mc/explo/udpor/Configuration_test.cpp | 114 ++++++++++----------- src/mc/explo/udpor/EventSet_test.cpp | 36 +++---- src/mc/explo/udpor/UnfoldingEvent_test.cpp | 90 ++++++++-------- src/mc/explo/udpor/udpor_tests_private.hpp | 30 +++++- 4 files changed, 149 insertions(+), 121 deletions(-) diff --git a/src/mc/explo/udpor/Configuration_test.cpp b/src/mc/explo/udpor/Configuration_test.cpp index e7f3e6f297..4fc70ff47c 100644 --- a/src/mc/explo/udpor/Configuration_test.cpp +++ b/src/mc/explo/udpor/Configuration_test.cpp @@ -27,11 +27,11 @@ TEST_CASE("simgrid::mc::udpor::Configuration: Constructing Configurations") // e3 // / / // e4 e5 - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e5(EventSet({&e3}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(0)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(1)); + UnfoldingEvent e3(EventSet({&e2}), std::make_shared(2)); + UnfoldingEvent e4(EventSet({&e3}), std::make_shared(3)); + UnfoldingEvent e5(EventSet({&e3}), std::make_shared(4)); SECTION("Creating a configuration without events") { @@ -96,10 +96,10 @@ TEST_CASE("simgrid::mc::udpor::Configuration: Adding Events") // / // / / // e3 e4 - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e2}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(0)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(1)); + UnfoldingEvent e3(EventSet({&e2}), std::make_shared(2)); + UnfoldingEvent e4(EventSet({&e2}), std::make_shared(3)); REQUIRE_THROWS_AS(Configuration().add_event(nullptr), std::invalid_argument); REQUIRE_THROWS_AS(Configuration().add_event(&e2), std::invalid_argument); @@ -139,10 +139,10 @@ TEST_CASE("simgrid::mc::udpor::Configuration: Topological Sort Order") // e3 // / // e4 - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e3}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(1)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(2)); + UnfoldingEvent e3(EventSet({&e2}), std::make_shared(3)); + UnfoldingEvent e4(EventSet({&e3}), std::make_shared(4)); SECTION("Topological ordering for entire set") { @@ -197,12 +197,12 @@ TEST_CASE("simgrid::mc::udpor::Configuration: Topological Sort Order More Compli // e4 e6 // / // e5 - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e5(EventSet({&e4}), std::make_shared()); - UnfoldingEvent e6(EventSet({&e3}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(1)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(2)); + UnfoldingEvent e3(EventSet({&e2}), std::make_shared(3)); + UnfoldingEvent e4(EventSet({&e3}), std::make_shared(4)); + UnfoldingEvent e5(EventSet({&e4}), std::make_shared(5)); + UnfoldingEvent e6(EventSet({&e3}), std::make_shared(6)); SECTION("Topological ordering for subsets") { @@ -306,18 +306,18 @@ TEST_CASE("simgrid::mc::udpor::Configuration: Topological Sort Order Very Compli // / / / // / / / // [ e12 ] - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e8(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e5(EventSet({&e4}), std::make_shared()); - UnfoldingEvent e6(EventSet({&e4}), std::make_shared()); - UnfoldingEvent e7(EventSet({&e2, &e8}), std::make_shared()); - UnfoldingEvent e9(EventSet({&e6, &e7}), std::make_shared()); - UnfoldingEvent e10(EventSet({&e7}), std::make_shared()); - UnfoldingEvent e11(EventSet({&e8}), std::make_shared()); - UnfoldingEvent e12(EventSet({&e5, &e9, &e10}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(1)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(2)); + UnfoldingEvent e8(EventSet({&e1}), std::make_shared(3)); + UnfoldingEvent e3(EventSet({&e2}), std::make_shared(4)); + UnfoldingEvent e4(EventSet({&e3}), std::make_shared(5)); + UnfoldingEvent e5(EventSet({&e4}), std::make_shared(6)); + UnfoldingEvent e6(EventSet({&e4}), std::make_shared(7)); + UnfoldingEvent e7(EventSet({&e2, &e8}), std::make_shared(8)); + UnfoldingEvent e9(EventSet({&e6, &e7}), std::make_shared(9)); + UnfoldingEvent e10(EventSet({&e7}), std::make_shared(10)); + UnfoldingEvent e11(EventSet({&e8}), std::make_shared(11)); + UnfoldingEvent e12(EventSet({&e5, &e9, &e10}), std::make_shared(12)); Configuration C{&e1, &e2, &e3, &e4, &e5, &e6, &e7, &e8, &e9, &e10, &e11, &e12}; SECTION("Test every combination of the maximal configuration (forward graph)") @@ -408,14 +408,14 @@ TEST_CASE("simgrid::mc::udpor::maximal_subsets_iterator: Basic Testing of Maxima // e3 e6 // / / / // e4 e7 e8 - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e5(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e6(EventSet({&e5}), std::make_shared()); - UnfoldingEvent e7(EventSet({&e6}), std::make_shared()); - UnfoldingEvent e8(EventSet({&e6}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(0)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(1)); + UnfoldingEvent e3(EventSet({&e2}), std::make_shared(2)); + UnfoldingEvent e4(EventSet({&e3}), std::make_shared(3)); + UnfoldingEvent e5(EventSet({&e1}), std::make_shared(4)); + UnfoldingEvent e6(EventSet({&e5}), std::make_shared(5)); + UnfoldingEvent e7(EventSet({&e6}), std::make_shared(6)); + UnfoldingEvent e8(EventSet({&e6}), std::make_shared(7)); SECTION("Iteration over an empty configuration yields only the empty set") { @@ -541,24 +541,24 @@ TEST_CASE("simgrid::mc::udpor::maximal_subsets_iterator: Stress Test for Maximal // | e11 e12 e13 e14 e15 // | / / / / / / // +-> e16 e17 e18 - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e5(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e6(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e7(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e8(EventSet({&e4}), std::make_shared()); - UnfoldingEvent e9(EventSet({&e4, &e5, &e6}), std::make_shared()); - UnfoldingEvent e10(EventSet({&e6, &e7}), std::make_shared()); - UnfoldingEvent e11(EventSet({&e8}), std::make_shared()); - UnfoldingEvent e12(EventSet({&e8}), std::make_shared()); - UnfoldingEvent e13(EventSet({&e9}), std::make_shared()); - UnfoldingEvent e14(EventSet({&e9}), std::make_shared()); - UnfoldingEvent e15(EventSet({&e10}), std::make_shared()); - UnfoldingEvent e16(EventSet({&e5, &e11}), std::make_shared()); - UnfoldingEvent e17(EventSet({&e12, &e13, &e14}), std::make_shared()); - UnfoldingEvent e18(EventSet({&e14, &e15}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(1)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(2)); + UnfoldingEvent e3(EventSet({&e1}), std::make_shared(3)); + UnfoldingEvent e4(EventSet({&e2}), std::make_shared(4)); + UnfoldingEvent e5(EventSet({&e2}), std::make_shared(5)); + UnfoldingEvent e6(EventSet({&e3}), std::make_shared(6)); + UnfoldingEvent e7(EventSet({&e3}), std::make_shared(7)); + UnfoldingEvent e8(EventSet({&e4}), std::make_shared(8)); + UnfoldingEvent e9(EventSet({&e4, &e5, &e6}), std::make_shared(9)); + UnfoldingEvent e10(EventSet({&e6, &e7}), std::make_shared(10)); + UnfoldingEvent e11(EventSet({&e8}), std::make_shared(11)); + UnfoldingEvent e12(EventSet({&e8}), std::make_shared(12)); + UnfoldingEvent e13(EventSet({&e9}), std::make_shared(13)); + UnfoldingEvent e14(EventSet({&e9}), std::make_shared(14)); + UnfoldingEvent e15(EventSet({&e10}), std::make_shared(15)); + UnfoldingEvent e16(EventSet({&e5, &e11}), std::make_shared(16)); + UnfoldingEvent e17(EventSet({&e12, &e13, &e14}), std::make_shared(17)); + UnfoldingEvent e18(EventSet({&e14, &e15}), std::make_shared(18)); Configuration C{&e1, &e2, &e3, &e4, &e5, &e6, &e7, &e8, &e9, &e10, &e11, &e12, &e13, &e14, &e15, &e16, &e17, &e18}; SECTION("Every subset iterated over is maximal") diff --git a/src/mc/explo/udpor/EventSet_test.cpp b/src/mc/explo/udpor/EventSet_test.cpp index 684ac5d32e..d414b60e5e 100644 --- a/src/mc/explo/udpor/EventSet_test.cpp +++ b/src/mc/explo/udpor/EventSet_test.cpp @@ -527,12 +527,12 @@ TEST_CASE("simgrid::mc::udpor::EventSet: Testing Configurations") // The tests enumerate all possible subsets of the events // in the structure and test whether those subsets are // maximal and/or valid configurations - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e5(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e6(EventSet({&e5}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(0)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(1)); + UnfoldingEvent e3(EventSet({&e2}), std::make_shared(2)); + UnfoldingEvent e4(EventSet({&e2}), std::make_shared(3)); + UnfoldingEvent e5(EventSet({&e1}), std::make_shared(4)); + UnfoldingEvent e6(EventSet({&e5}), std::make_shared(5)); SECTION("Valid Configurations") { @@ -778,12 +778,12 @@ TEST_CASE("simgrid::mc::udpor::EventSet: Checking conflicts") SECTION("No conflicts throughout the whole structure with independent actions") { - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e5(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e6(EventSet({&e5}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(0)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(1)); + UnfoldingEvent e3(EventSet({&e2}), std::make_shared(2)); + UnfoldingEvent e4(EventSet({&e2}), std::make_shared(3)); + UnfoldingEvent e5(EventSet({&e1}), std::make_shared(4)); + UnfoldingEvent e6(EventSet({&e5}), std::make_shared(5)); // 6 choose 0 = 1 test CHECK(EventSet().is_conflict_free()); @@ -958,12 +958,12 @@ TEST_CASE("simgrid::mc::udpor::EventSet: Checking conflicts") SECTION("Conditional conflicts") { - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e5(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e6(EventSet({&e5}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(0)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(1)); + UnfoldingEvent e3(EventSet({&e2}), std::make_shared(2)); + UnfoldingEvent e4(EventSet({&e2}), std::make_shared(3)); + UnfoldingEvent e5(EventSet({&e1}), std::make_shared(4)); + UnfoldingEvent e6(EventSet({&e5}), std::make_shared(5)); // 6 choose 0 = 1 test // There are no events even to be in conflict with diff --git a/src/mc/explo/udpor/UnfoldingEvent_test.cpp b/src/mc/explo/udpor/UnfoldingEvent_test.cpp index a676c69fdb..df316fdb7b 100644 --- a/src/mc/explo/udpor/UnfoldingEvent_test.cpp +++ b/src/mc/explo/udpor/UnfoldingEvent_test.cpp @@ -119,13 +119,13 @@ TEST_CASE("simgrid::mc::udpor::UnfoldingEvent: Dependency/Conflict Tests") // e4 e5 e7 // // e5 and e6 are in conflict, e5 and e7 are in conflict, e2 and e6, and e2 ands e7 are in conflict - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e5(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e6(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e7(EventSet({&e6, &e2}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(0)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(0)); + UnfoldingEvent e3(EventSet({&e2}), std::make_shared(0)); + UnfoldingEvent e4(EventSet({&e3}), std::make_shared(1)); + UnfoldingEvent e5(EventSet({&e3}), std::make_shared(1)); + UnfoldingEvent e6(EventSet({&e1}), std::make_shared(2)); + UnfoldingEvent e7(EventSet({&e6, &e2}), std::make_shared(3)); SECTION("Dependency relation properties") { @@ -180,7 +180,7 @@ TEST_CASE("simgrid::mc::udpor::UnfoldingEvent: Dependency/Conflict Tests") } } - SECTION("No conflicts whatsoever") + SECTION("Testing with no dependencies whatsoever") { // The following tests concern the given event structure: // e1 @@ -190,19 +190,20 @@ TEST_CASE("simgrid::mc::udpor::UnfoldingEvent: Dependency/Conflict Tests") // e3 / / // / / / // e4 e5 e7 - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e5(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e6(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e7(EventSet({&e6, &e2}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(0)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(1)); + UnfoldingEvent e3(EventSet({&e2}), std::make_shared(2)); + UnfoldingEvent e4(EventSet({&e3}), std::make_shared(3)); + UnfoldingEvent e5(EventSet({&e3}), std::make_shared(4)); + UnfoldingEvent e6(EventSet({&e1}), std::make_shared(5)); + UnfoldingEvent e7(EventSet({&e6, &e2}), std::make_shared(6)); // Since everyone's actions are independent of one another, we expect - // that there are no conflicts between each pair of events + // that there are no conflicts between each pair of events (except with + // the same event itself) SECTION("Mutual dependencies") { - CHECK_FALSE(e1.is_dependent_with(&e1)); + CHECK(e1.is_dependent_with(&e1)); CHECK_FALSE(e1.is_dependent_with(&e2)); CHECK_FALSE(e1.is_dependent_with(&e3)); CHECK_FALSE(e1.is_dependent_with(&e4)); @@ -210,32 +211,32 @@ TEST_CASE("simgrid::mc::udpor::UnfoldingEvent: Dependency/Conflict Tests") CHECK_FALSE(e1.is_dependent_with(&e6)); CHECK_FALSE(e1.is_dependent_with(&e7)); - CHECK_FALSE(e2.is_dependent_with(&e2)); + CHECK(e2.is_dependent_with(&e2)); CHECK_FALSE(e2.is_dependent_with(&e3)); CHECK_FALSE(e2.is_dependent_with(&e4)); CHECK_FALSE(e2.is_dependent_with(&e5)); CHECK_FALSE(e2.is_dependent_with(&e6)); CHECK_FALSE(e2.is_dependent_with(&e7)); - CHECK_FALSE(e3.is_dependent_with(&e3)); + CHECK(e3.is_dependent_with(&e3)); CHECK_FALSE(e3.is_dependent_with(&e4)); CHECK_FALSE(e3.is_dependent_with(&e5)); CHECK_FALSE(e3.is_dependent_with(&e6)); CHECK_FALSE(e3.is_dependent_with(&e7)); - CHECK_FALSE(e4.is_dependent_with(&e4)); + CHECK(e4.is_dependent_with(&e4)); CHECK_FALSE(e4.is_dependent_with(&e5)); CHECK_FALSE(e4.is_dependent_with(&e6)); CHECK_FALSE(e4.is_dependent_with(&e7)); - CHECK_FALSE(e5.is_dependent_with(&e5)); + CHECK(e5.is_dependent_with(&e5)); CHECK_FALSE(e5.is_dependent_with(&e6)); CHECK_FALSE(e5.is_dependent_with(&e7)); - CHECK_FALSE(e6.is_dependent_with(&e6)); + CHECK(e6.is_dependent_with(&e6)); CHECK_FALSE(e6.is_dependent_with(&e7)); - CHECK_FALSE(e7.is_dependent_with(&e7)); + CHECK(e7.is_dependent_with(&e7)); } SECTION("Mutual conflicts") @@ -298,7 +299,7 @@ TEST_CASE("simgrid::mc::udpor::UnfoldingEvent: Dependency/Conflict Tests") } } - SECTION("General conflicts") + SECTION("Testing with some conflicts") { // The following tests concern the given event structure: // e1 @@ -308,16 +309,17 @@ TEST_CASE("simgrid::mc::udpor::UnfoldingEvent: Dependency/Conflict Tests") // e3 / / // / / / // e4 e5 e7 - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e5(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e6(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e7(EventSet({&e6, &e2}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(0)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(1)); + UnfoldingEvent e3(EventSet({&e2}), std::make_shared(2)); + UnfoldingEvent e4(EventSet({&e3}), std::make_shared(3)); + UnfoldingEvent e5(EventSet({&e3}), std::make_shared(4)); + UnfoldingEvent e6(EventSet({&e1}), std::make_shared(5)); + UnfoldingEvent e7(EventSet({&e6, &e2}), std::make_shared(6)); // Since everyone's actions are independent of one another, we expect - // that there are no conflicts between each pair of events + // that there are no conflicts between each pair of events (except the pair + // with the event and itself) SECTION("Mutual dependencies") { CHECK(e1.is_dependent_with(&e1)); @@ -335,25 +337,25 @@ TEST_CASE("simgrid::mc::udpor::UnfoldingEvent: Dependency/Conflict Tests") CHECK_FALSE(e2.is_dependent_with(&e6)); CHECK(e2.is_dependent_with(&e7)); - CHECK_FALSE(e3.is_dependent_with(&e3)); + CHECK(e3.is_dependent_with(&e3)); CHECK_FALSE(e3.is_dependent_with(&e4)); CHECK_FALSE(e3.is_dependent_with(&e5)); CHECK_FALSE(e3.is_dependent_with(&e6)); CHECK_FALSE(e3.is_dependent_with(&e7)); - CHECK_FALSE(e4.is_dependent_with(&e4)); + CHECK(e4.is_dependent_with(&e4)); CHECK_FALSE(e4.is_dependent_with(&e5)); CHECK_FALSE(e4.is_dependent_with(&e6)); CHECK_FALSE(e4.is_dependent_with(&e7)); - CHECK_FALSE(e5.is_dependent_with(&e5)); + CHECK(e5.is_dependent_with(&e5)); CHECK_FALSE(e5.is_dependent_with(&e6)); CHECK_FALSE(e5.is_dependent_with(&e7)); - CHECK_FALSE(e6.is_dependent_with(&e6)); + CHECK(e6.is_dependent_with(&e6)); CHECK_FALSE(e6.is_dependent_with(&e7)); - CHECK_FALSE(e7.is_dependent_with(&e7)); + CHECK(e7.is_dependent_with(&e7)); } SECTION("Mutual conflicts") @@ -430,13 +432,13 @@ TEST_CASE("simgrid::mc::udpor::UnfoldingEvent: Dependency/Conflict Tests") // e3 / // / / e7 // e4 e5 - UnfoldingEvent e1(EventSet(), std::make_shared()); - UnfoldingEvent e2(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e3(EventSet({&e2}), std::make_shared()); - UnfoldingEvent e4(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e5(EventSet({&e3}), std::make_shared()); - UnfoldingEvent e6(EventSet({&e1}), std::make_shared()); - UnfoldingEvent e7(EventSet({&e6}), std::make_shared()); + UnfoldingEvent e1(EventSet(), std::make_shared(0)); + UnfoldingEvent e2(EventSet({&e1}), std::make_shared(1)); + UnfoldingEvent e3(EventSet({&e2}), std::make_shared(2)); + UnfoldingEvent e4(EventSet({&e3}), std::make_shared(3)); + UnfoldingEvent e5(EventSet({&e3}), std::make_shared(4)); + UnfoldingEvent e6(EventSet({&e1}), std::make_shared(5)); + UnfoldingEvent e7(EventSet({&e6}), std::make_shared(6)); CHECK_FALSE(e1.conflicts_with(&e1)); CHECK_FALSE(e1.conflicts_with(&e2)); diff --git a/src/mc/explo/udpor/udpor_tests_private.hpp b/src/mc/explo/udpor/udpor_tests_private.hpp index fabc2fc229..de2ed37dce 100644 --- a/src/mc/explo/udpor/udpor_tests_private.hpp +++ b/src/mc/explo/udpor/udpor_tests_private.hpp @@ -19,18 +19,37 @@ namespace simgrid::mc::udpor { struct IndependentAction : public Transition { IndependentAction() = default; IndependentAction(Type type, aid_t issuer, int times_considered = 0) : Transition(type, issuer, times_considered) {} + IndependentAction(aid_t issuer, int times_considered = 0) + : IndependentAction(simgrid::mc::Transition::Type::UNKNOWN, issuer, times_considered) + { + } - // Independent with everyone else - bool depends(const Transition* other) const override { return false; } + // Independent with everyone else (even if run by the same actor). NOTE: This is + // only for the convenience of testing: in general, transitions are dependent with + // one another if run by the same actor + bool depends(const Transition* other) const override + { + if (aid_ == other->aid_) { + return true; + } + return false; + } }; struct DependentAction : public Transition { DependentAction() = default; DependentAction(Type type, aid_t issuer, int times_considered = 0) : Transition(type, issuer, times_considered) {} + DependentAction(aid_t issuer, int times_considered = 0) + : DependentAction(simgrid::mc::Transition::Type::UNKNOWN, issuer, times_considered) + { + } // Dependent with everyone else (except IndependentAction) bool depends(const Transition* other) const override { + if (aid_ == other->aid_) { + return true; + } return dynamic_cast(other) == nullptr; } }; @@ -41,10 +60,17 @@ struct ConditionallyDependentAction : public Transition { : Transition(type, issuer, times_considered) { } + ConditionallyDependentAction(aid_t issuer, int times_considered = 0) + : ConditionallyDependentAction(simgrid::mc::Transition::Type::UNKNOWN, issuer, times_considered) + { + } // Dependent only with DependentAction (i.e. not itself) bool depends(const Transition* other) const override { + if (aid_ == other->aid_) { + return true; + } return dynamic_cast(other) != nullptr; } }; -- 2.20.1