Instantiation namespace 'Test Suites'::'Test Suite 1'::Assembly_P_P ; private import 'Test Suites'::Utils::* ; activity TestCase_Assembly_P_P() { helper = new AssertCompositeHelper() ; WriteLine("-- Running test case: Assembly connector between two parts --") ; // Testing instantiation of A_Empty_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Empty_Pattern -") ; a_empty = new A_Empty_Pattern(); AssertEmptyPattern(a_empty.b, a_empty.c) ; // Testing instantiation of A_Unconnected_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Unconnected_Pattern -") ; a_unconnected = new A_Unconnected_Pattern(); AssertUnconnectedPattern(a_unconnected.b, a_unconnected.c, 2, 3, helper) ; // Testing instantiation of A_Array_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Array_Pattern") ; a_array = new A_Array_Pattern(); AssertArrayPattern(a_array.b, a_array.c, 4, helper) ; // Testing instantiation of A_Star_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Star_Pattern") ; a_star = new A_Star_Pattern(); AssertStarPattern(a_star.b, a_star.c, 4, 3, helper) ; WriteLine("-- End of test case --") ; } Empty pattern: lower bound of part b and c is 0 Array pattern: lower bound of b and c are equals lower bound on ends of connector r is 1 Star pattern: lower bound on ends of connector r equal lower bound of connected parts IntegerFunctions::Min('#ends1', n1) ; namespace 'Test Suites'::'Test Suite 1'::Assembly_P_P::AssertCompositeHelper ; private import Alf::Library::CollectionFunctions::includes ; activity assertConnected(in message : String, in end1 : any, in end2 : any) { AssertTrue(message, R::y((B)end1)->includes((C)end2)) ; } namespace 'Test Suites'::'Test Suite 1'::Assembly_P_P::AssertCompositeHelper ; private import Alf::Library::CollectionFunctions::includes ; activity assertNotConnected(in message : String, in end1 : any, in end2 : any) { AssertTrue(message, ! R::y((B)end1)->includes((C)end2)) ; } Unconnected pattern: lower bound on ends of connector r is 0 namespace 'Test Suites'::'Test Suite 1' ; private import 'Test Suites'::'Test Suite 1'::Assembly_P_P::* ; private import 'Test Suites'::'Test Suite 1'::Assembly_PWP_P::* ; private import 'Test Suites'::'Test Suite 1'::Assembly_PWP_PWP::* ; private import 'Test Suites'::'Test Suite 1'::'DefaultValues - BasicTypes'::* ; private import 'Test Suites'::'Test Suite 1'::'DefaultValues - Structures'::* ; private import 'Test Suites'::'Test Suite 1'::Delegation_Port_P::* ; private import 'Test Suites'::'Test Suite 1'::Delegation_Port_PWP::* ; private import 'Test Suites'::'Test Suite 1'::Hierarchy::* ; /** * Runs all test cases defined in Test Suite 1 */ activity 'Test Suite 1'() { WriteLine("---- Running Test Suite 1 ----") ; WriteLine("") ; TestCase_Assembly_P_P () ; WriteLine("") ; TestCase_Assembly_PWP_P () ; WriteLine("") ; TestCase_Assembly_PWP_PWP () ; WriteLine("") ; TestCase_Delegation_Port_P () ; WriteLine("") ; TestCase_Delegation_Port_PWP () ; WriteLine("") ; TestCase_Hierarchy() ; WriteLine("") ; 'Test Case - Default Values'() ; WriteLine("") ; 'Test Case - Default Values - Structures'() ; WriteLine("") ; WriteLine("") ; WriteLine("---- End of Test Suite 1 ----") ; } activity Construct() : B{ // Instantiates interaction points for (i in 1..2) { this.p -> add(new IImpl()) ; } return this ; } namespace 'Test Suites'::'Test Suite 1'::Assembly_PWP_P ; private import 'Test Suites'::Utils::* ; activity TestCase_Assembly_PWP_P() { helper = new AssertCompositeHelper() ; WriteLine("-- Running test case: Assembly connector between a part with port and a part --") ; // Testing instantiation of A_Empty_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Empty_Pattern -") ; a_empty = new A_Empty_Pattern() ; AssertEmptyPattern(a_empty.b, a_empty.c) ; // Testing instantiation of A_Unconnected_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Unconnected_Pattern -") ; a_unconnected = new A_Unconnected_Pattern(); AssertUnconnectedPattern(a_unconnected.b.p, a_unconnected.c, 4, 3, helper) ; // Testing instantiation of A_Array_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Array_Pattern -") ; a_array = new A_Array_Pattern(); AssertArrayPattern(a_array.b.p, a_array.c, 4, helper) ; // Testing instantiation of A_Star_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Star_Pattern -") ; a_star = new A_Star_Pattern(); AssertStarPattern(a_star.b.p, a_star.c, 4, 5, helper) ; } Empty pattern: lower bound of part b and c is 0 Array pattern: lower bound of b and c are equals lower bound on ends of connector r is 1 Star pattern: lower bound on ends of connector r equal lower bound of connected parts IntegerFunctions::Min('#ends1', n1) ; namespace 'Test Suites'::'Test Suite 1'::Assembly_PWP_P::AssertCompositeHelper ; private import Alf::Library::CollectionFunctions::includes ; activity assertConnected(in message : String, in end1 : any, in end2 : any) { AssertTrue(message, R::y((IImpl)end1)->includes((C)end2)) ; } namespace 'Test Suites'::'Test Suite 1'::Assembly_PWP_P::AssertCompositeHelper ; private import Alf::Library::CollectionFunctions::includes ; activity assertNodeConnected_method(in message : String, in end1 : any, in end2 : any) { AssertTrue(message, ! R::y((IImpl)end1)->includes((C)end2)) ; } Unconnected pattern: lower bound on ends of connector r is 0 activity Construct() : B{ // Instantiates interaction points for (i in 1..2) { this.p -> add(new IImpl()) ; } return this ; } activity Construct() : C { // Instantiate port this.q = new IImpl() ; } namespace 'Test Suites'::'Test Suite 1'::Assembly_PWP_PWP ; private import 'Test Suites'::Utils::* ; activity TestCase_Assembly_PWP_PWP () { helper = new AssertCompositeHelper() ; WriteLine("-- Running test case: Assembly connector between a part with port and a part with port --") ; // Testing instantiation of A_Empty_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Empty_Pattern -") ; a_empty = new A_Empty_Pattern() ; AssertEmptyPattern(a_empty.b, a_empty.c) ; // Testing instantiation of A_Unconnected_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Unconnected_Pattern -") ; a_unconnected = new A_Unconnected_Pattern(); AssertUnconnectedPattern(a_unconnected.b.p, a_unconnected.c.q, 4, 3, helper) ; // Testing instantiation of A_Array_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Array_Pattern -") ; a_array = new A_Array_Pattern(); AssertArrayPattern(a_array.b.p, a_array.c.q, 4, helper) ; // Testing instantiation of A_Star_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Star_Pattern -") ; a_star = new A_Star_Pattern(); AssertStarPattern(a_star.b.p, a_star.c.q, 4, 5, helper) ; } Empty pattern: lower bound of part b and c is 0 Array pattern: lower bound of b and c are equals lower bound on ends of connector r is 1 Star pattern: lower bound on ends of connector r equal lower bound of connected parts IntegerFunctions::Min('#ends1', n1) ; namespace 'Test Suites'::'Test Suite 1'::Assembly_PWP_PWP::AssertCompositeHelper ; private import Alf::Library::CollectionFunctions::includes ; activity assertConnected(in message : String, in end1 : any, in end2 : any) { AssertTrue(message, R::y((IImpl)end1)->includes((IImpl)end2)) ; } namespace 'Test Suites'::'Test Suite 1'::Assembly_PWP_PWP::AssertCompositeHelper ; private import Alf::Library::CollectionFunctions::includes ; activity assertNodeConnected_method(in message : String, in end1 : any, in end2 : any) { AssertTrue(message, ! R::y((IImpl)end1)->includes((IImpl)end2)) ; } Unconnected pattern: lower bound on ends of connector r is 0 namespace 'Test Suites'::'Test Suite 1'::Delegation_Port_P ; private import 'Test Suites'::Utils::* ; activity TestCase_Delegation_Port_P() { helper = new AssertCompositeHelper() ; WriteLine("-- Running test case: Delegation connector between a port and a part --") ; a = new A_Array_Pattern() ; // Testing instantiation of A_Empty_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Empty_Pattern -") ; a_empty = new A_Empty_Pattern(); AssertEmptyPattern(a_empty.p, a_empty.b) ; // Testing instantiation of A_Unconnected_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Unconnected_Pattern -") ; a_unconnected = new A_Unconnected_Pattern(); AssertUnconnectedPattern(a_unconnected.p, a_unconnected.b, 3, 2, helper) ; // Testing instantiation of A_Array_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Array_Pattern") ; a_array = new A_Array_Pattern(); AssertArrayPattern(a_array.p, a_array.b, 4, helper) ; // Testing instantiation of A_Star_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Star_Pattern") ; a_star = new A_Star_Pattern(); AssertStarPattern(a_star.p, a_star.b, 3, 4, helper) ; } Empty pattern: lower bound of port p and part b is 0 Array pattern: lower bound of p and b are equals lower bound on ends of connector r is 1 Star pattern: lower bound on ends of connector r equal lower bound of connected elements IntegerFunctions::Min('#ends1', n1) ; namespace 'Test Suites'::'Test Suite 1'::Delegation_Port_P::AssertCompositeHelper ; activity assertConnected(in message : String, in end1 : any, in end2 : any) { AssertTrue(message, R::y((IImpl)end1)->includes((B)end2)) ; } namespace 'Test Suites'::'Test Suite 1'::Delegation_Port_P::AssertCompositeHelper ; activity assertNotConnected(in message : String, in end1 : any, in end2 : any) { AssertTrue(message, ! R::y((IImpl)end1)->includes((B)end2)) ; } Unconnected pattern: lower bound on ends of connector r is 0 activity Construct() : B{ // Instantiate port q for (i in 1..2) { this.q->add(new IImpl()) ; } } namespace 'Test Suites'::'Test Suite 1'::Delegation_Port_PWP ; private import 'Test Suites'::Utils::* ; activity TestCase_Assembly_Port_PWP() { helper = new AssertCompositeHelper() ; WriteLine("-- Running test case: Delegation connector between a port and a part with port --") ; // Testing instantiation of A_Empty_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Empty_Pattern -") ; a_empty = new A_Empty_Pattern(); AssertEmptyPattern(a_empty.p, a_empty.b) ; // Testing instantiation of A_Unconnected_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Unconnected_Pattern -") ; a_unconnected = new A_Unconnected_Pattern(); AssertUnconnectedPattern(a_unconnected.p, a_unconnected.b.q, 3, 4, helper) ; // Testing instantiation of A_Array_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Array_Pattern -") ; a_array = new A_Array_Pattern(); AssertArrayPattern(a_array.p, a_array.b.q, 4, helper) ; // Testing instantiation of A_Star_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Star_Pattern -") ; a_star = new A_Star_Pattern(); AssertStarPattern(a_star.p, a_star.b.q, 3, 4, helper) ; } Empty pattern: lower bound of port p and part b is 0 Array pattern: lower bound of p and b*q are equals lower bound on ends of connector r is 1 Star pattern: lower bound on ends of connector r equal lower bound of connected elements IntegerFunctions::Min('#ends1', n1) ; namespace 'Test Suites'::'Test Suite 1'::Delegation_Port_PWP::AssertCompositeHelper ; activity assertConnected(in message : String, in end1 : any, in end2 : any) { AssertTrue(message, R::y((IImpl)end1)->includes((IImpl)end2)) ; } namespace 'Test Suites'::'Test Suite 1'::Delegation_Port_PWP::AssertCompositeHelper ; activity assertNotConnected_method(in message : String, in end1 : any, in end2 : any) { AssertTrue(message, ! R::y((IImpl)end1)->includes((IImpl)end2)) ; } Unconnected pattern: lower bound on ends of connector r is 0 namespace 'Test Suites'::'Test Suite 1'::Hierarchy ; private import FoundationalModelLibrary::PrimitiveBehaviors::ListFunctions::* ; private import 'Test Suites'::Utils::* ; activity TestCase_Hierarchy() { a = new A() ; WriteLine("-- Running test case: Hierarchical instantiation --") ; // a.b is not empty WriteLine("") ; AssertTrue("a.b is not empty", ListSize(a.b) > 0) ; // a.b.c is not empty AssertTrue("a.b.c is not empty", ListSize(a.b.c) > 0) ; // a.b.c.d is not empty AssertTrue("a.b.c.d is not empty", ListSize(a.b.c.d) > 0) ; // a.b.c.d.e is empty (e is not shared, not composite) AssertTrue("a.b.c.d.e is empty", ListSize(a.b.c.d.e) == 0) ; } namespace 'Test Suites'::'Test Suite 1'::'DefaultValues - BasicTypes' ; private import AssertionLibrary::* ; activity 'Test Case - Default Values'() { WriteLine("-- Running test case - Instantiation of Default values - basic types --") ; a = new A() ; AssertEquals("Default value of a.pInteger", a.pInteger, 4) ; AssertEquals("Default value of a.pString", a.pString, "Hello") ; AssertEquals("Default value of a.pBoolean", a.pBoolean, true) ; AssertEquals("Default value of a.pUnlimitedNatural", a.pUnlimitedNatural, *) ; // AssertEquals("Default value of a.pReal", a.pReal, 4.0) ; AssertEquals("Default value of a.pEnum", a.pEnum, E::e2) ; WriteLine("-- End of test case --") ; } /* Generated textual representation of Activity Test Suites::Test Suite 1::DefaultValues - Structures::A::bDefaultValues */ namespace 'Test Suites'::'Test Suite 1'::'DefaultValues - Structures'::A ; activity bDefaultValues() : B[]{ b1 = new B() ; b1.p = 1 ; b2 = new B() ; b2.p = 2 ; b3 = new B() ; b3.p = 3 ; b4 = new B() ; b4.p = 4 ; return new B[]{b1, b2, b3, b4} ; } namespace 'Test Suites'::'Test Suite 1'::'DefaultValues - Structures' ; activity 'Test Case - Default Values - Structures'() { WriteLine("-- Running test case - Instantiation of Default values - Structures --") ; a = new A() ; AssertEquals("Default value of a.b[1].p", a.b[1].p, 1) ; AssertEquals("Default value of a.b[2].p", a.b[2].p, 2) ; AssertEquals("Default value of a.b[3].p", a.b[3].p, 3) ; AssertEquals("Default value of a.b[4].p", a.b[4].p, 4) ; WriteLine("-- End of test case --") ; } // Testing instantiation of A_Star_Pattern WriteLine("Testing instantiation of A_Star_Pattern") ; a_star = new A_Star_Pattern(); helper.assertStarPattern(a_star.b, a_star.c) ; namespace 'Test Suites'::Utils::AbstractAssertCompositeHelper ; private import Alf::Library::CollectionFunctions::size ; activity AssertEmptyPattern(in ends1 : any[], in ends2 : any[]) { AssertEquals("EmptyPattern - ends1->size()", ends1->size(), 0) ; AssertEquals("EmptyPattern - ends2->size()", ends2->size(), 0) ; } namespace 'Test Suites'::Utils ; private import Alf::Library::CollectionFunctions::size ; private import Alf::Library::PrimitiveBehaviors::IntegerFunctions::Min ; private import Alf::Library::PrimitiveBehaviors::IntegerFunctions::ToString ; activity AssertArrayPattern(in ends1 : any[], in ends2 : any[], in n : Integer, in helper : AbstractAssertCompositeHelper) { // Check cardinalities AssertEquals("ArrayPattern - ends1->size()", ends1->size(), n) ; AssertEquals("ArrayPattern - ends2->size()", ends2->size(), n) ; upper = Min(ends1->size(), ends2->size()) ; // Check connections for (i in 1..upper) { for (j in 1..upper) { if (i == j) { helper.assertConnected("ArrayPattern - ends1[" + ToString(i) + "] is connected to ends2[" + ToString(j) + "]",ends1[i], ends2[j]) ; } else { helper.assertNotConnected("ArrayPattern - ends1[" + ToString(i) + "] is not connected to ends2[" + ToString(j) + "]",ends1[i], ends2[j]) ; } } } } namespace 'Test Suites'::Utils ; private import Alf::Library::CollectionFunctions::size ; private import Alf::Library::PrimitiveBehaviors::IntegerFunctions::ToString ; activity AssertStarPattern(in ends1 : any[], in ends2 : any[], in n1 : Integer, in n2 : Integer, in helper : AbstractAssertCompositeHelper) { // Check cardinalities AssertEquals("StarPattern - ends1->size()", ends1->size(), n1) ; AssertEquals("StarPattern - ends2->size()", ends2->size(), n2) ; // Checks connections for (i in 1..ends1->size()) { for (j in 1..ends2->size()) { helper.assertConnected("StarPattern - ends1[" + ToString(i) + "] is connected to ends2[" + ToString(j) + "]",ends1[i], ends2[j]) ; } } } namespace 'Test Suites'::Utils ; private import Alf::Library::CollectionFunctions::size ; private import Alf::Library::PrimitiveBehaviors::IntegerFunctions::ToString ; activity AssertUnconnectedPattern(in ends1 : any[], in ends2 : any[], in n1 : Integer, in n2 : Integer, in helper : AbstractAssertCompositeHelper) { // Check cardinalities AssertEquals("UnconnectedPattern - ends1->size()", ends1->size(), n1) ; AssertEquals("UnconnectedPattern - ends2->size()", ends2->size(), n2) ; // Checks connections for (i in 1..ends1->size()) { for (j in 1..ends2->size()) { helper.assertNotConnected("UnconnectedPattern - ends1[" + ToString(i) + "] is not connected to ends2[" + ToString(j) + "]",ends1[i], ends2[j]) ; } } } Communication isBehavior = false namespace 'Test Suites'::'Test Suite 2'::'Loss of Messages - Signal'::A ; private import 'Test Suites'::'Test Suite 2'::'Loss of Messages - Signal'::S ; activity AClassifierBehavior() { accept (s : S) { this.p = s.v ; } } namespace 'Test Suites'::'Test Suite 2'::'Loss of Messages - Signal' ; activity 'Test case - Loss of Messages - Signal'() { WriteLine("-- Running test case: Loss of Signal on non-behavior ports with no delegation connector --") ; // Instantiate A a = new A() ; a.q.S(4) ; AssertFalse("Signal received", a.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'Loss of Messages - Operation'::A ; activity AClassifierBehavior() { // FIXME: This classifier behavior shall not exist. To be removed when Alf to fUML compiler is patched. } namespace 'Test Suites'::'Test Suite 2'::'Loss of Messages - Operation'::A ; activity setP(in v : Integer) { this.p = v ; } namespace 'Test Suites'::'Test Suite 2'::'Loss of Messages - Operation' ; activity 'Test case - Loss of Messages - Operation'() { WriteLine("-- Running test case: Loss of Operation call on non-behavior ports with no delegation connector --") ; // Instantiate A a = new A() ; a.q.setP(4) ; AssertFalse("Operation call received", a.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::A ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::S ; activity AClassifierBehavior() { accept (s : S) { this.p = s.v ; s.t.Continue() ; } } namespace 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal' ; activity 'Test case - BehaviorPort - Signal'() { // Instantiate Tester t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Reception of a Signal on a behavior port --") ; AssertTrue("Signal delegated to classifier behavior", this.a.p == 4) ; WriteLine("-- End of test case --") ; } /* Generated textual representation of Activity Test Suites::Test Suite 2::BehaviorPort - Signal::Tester::TesterClassifierBehavior */ namespace 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.a.q.S(4, this) ; accept(Continue) ; this.test() ; } namespace 'Test Suites'::'Test Suite 2' ; private import 'Test Suites'::'Test Suite 2'::'Loss of Messages - Signal'::* ; private import 'Test Suites'::'Test Suite 2'::'Loss of Messages - Operation'::* ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::* ; private import 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPart - Signal'::* ; private import 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPart - Operation'::* ; private import 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPWP - Signal'::* ; private import 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPWP - Operation'::* ; private import 'Test Suites'::'Test Suite 2'::'MultipleDelegation - SameConnector - PortToPart - Signal'::* ; private import 'Test Suites'::'Test Suite 2'::'MultipleDelegation - SameConnector - PortToPart - Operation'::* ; private import 'Test Suites'::'Test Suite 2'::'MultipleDelegation - SameConnector - PortToPWP - Signal'::* ; private import 'Test Suites'::'Test Suite 2'::'MultipleDelegation - SameConnector - PortToPWP - Operation'::* ; private import 'Test Suites'::'Test Suite 2'::'MultipleDelegation - MultipleConnectors - PortToPart - Signal'::* ; private import 'Test Suites'::'Test Suite 2'::'MultipleDelegation - MultipleConnectors - PortToPWP - Signal'::* ; private import 'Test Suites'::'Test Suite 2'::'MultipleDelegation - MultipleConnectors - PortToPart - Operation'::* ; private import 'Test Suites'::'Test Suite 2'::'MultipleDelegation - MultipleConnectors - PortToPWP - Operation'::* ; activity 'Test Suite 2'() { WriteLine("---- Running Test Suite 2 ----") ; WriteLine("") ; 'Test case - BehaviorPort - Signal'() ; WriteLine("") ; 'Test case - Loss of Messages - Operation'() ; WriteLine("") ; 'Test case - Loss of Messages - Signal'() ; WriteLine("") ; 'Test case - MultipleDelegation - MultipleConnectors - PortToPart - Operation'() ; WriteLine("") ; 'Test case - MultipleDelegation - MultipleConnectors - PortToPart - Signal'() ; WriteLine("") ; 'Test case - MultipleDelegation - MultipleConnectors - PortToPWP - Operation'() ; WriteLine("") ; 'Test case - MultipleDelegation - MultipleConnectors - PortToPWP - Signal'() ; WriteLine("") ; 'Test case - MultipleDelegation - SameConnector - PortToPart - Operation'() ; WriteLine("") ; 'Test case - MultipleDelegation - SameConnector - PortToPart - Signal'() ; WriteLine("") ; 'Test case - MultipleDelegation - SameConnector - PortToPWP - Operation'() ; WriteLine("") ; 'Test case - MultipleDelegation - SameConnector - PortToPWP - Signal'() ; WriteLine("") ; 'Test case - SingleDelegation - PortToPart - Operation'() ; WriteLine("") ; 'Test case - SingleDelegation - PortToPart - Signal'() ; WriteLine("") ; 'Test case - SingleDelegation - PortToPWP - Operation'() ; WriteLine("") ; 'Test case - SingleDelegation - PortToPWP - Signal'() ; WriteLine("") ; WriteLine("") ; WriteLine("---- End of Test Suite 2 ----") ; } namespace 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPart - Signal' ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::AbstractTester ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Start ; activity 'Test case - SingleDelegation - PortToPart - Signal'() { AbstractTester t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPart - Signal'::B ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::S ; activity BClassifierBehavior() { accept (s : S) { this.p = s.v ; s.t.Continue() ; } } namespace 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPart - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Single delegation connector - Signal delegated from port to part --") ; AssertTrue("Signal delegated to classifier behavior", this.a.b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPart - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.a.q.S(4, this) ; accept(Continue) ; this.test() ; } namespace 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPart - Operation' ; activity 'Test case - SingleDelegation - PortToPart - Operation'() { WriteLine("-- Running test case: Single delegation connector - Operation delegated from port to part --") ; // Instantiate A a = new A() ; a.q.setP(4) ; AssertTrue("Operation call delegated", a.b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPart - Operation'::B ; activity BClassifierBehavior() { // FIXME: This classifier behavior shall not exist. To be removed when Alf to fUML compiler is patched. } namespace 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPart - Operation'::B ; activity setP(in v : Integer) { this.p = v ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - SameConnector - PortToPart - Signal' ; activity 'Test case - MultipleDelegation - SameConnector - PortToPart - Signal'() { t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - SameConnector - PortToPart - Signal'::B ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::S ; activity BClassifierBehavior() { accept (s : S) { this.p = s.v ; s.t.Continue() ; } } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - SameConnector - PortToPart - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Single delegation connector - Multiple links - Signal delegated from port to part --") ; AssertTrue("Signal delegated on all links (shall be true for default strategy)", this.a.b[1].p == 4 && this.a.b[2].p == 4 && this.a.b[3].p == 4 && this.a.b[4].p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - SameConnector - PortToPart - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.a.q.S(4, this) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; this.test() ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - MultipleConnectors - PortToPart - Signal' ; activity 'Test case - MultipleDelegation - MultipleConnectors - PortToPart - Signal'() { t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - MultipleConnectors - PortToPart - Signal'::B ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::S ; activity BClassifierBehavior() { accept (s : S) { this.p = s.v ; s.t.Continue() ; } } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - MultipleConnectors - PortToPart - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Multiple delegation connectors - Multiple links - Signal delegated from port to part --") ; AssertTrue("Signal delegated on all links (shall be true for default strategy)", this.a.b1.p == 4 && this.a.b2.p == 4 && this.a.b3.p == 4 && this.a.b4.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - MultipleConnectors - PortToPart - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.a.q.S(4, this) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; this.test() ; } namespace 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPWP - Signal' ; //private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Start ; activity 'Test case - SingleDelegation - PortToPWP - Signal'() { t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPWP - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Single delegation connector - Signal delegated from port to part with port --") ; AssertTrue("Signal delegated", this.c.a.b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPWP - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.c.p.S(4, this) ; accept(Continue) ; this.test() ; } namespace 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPWP - Operation' ; activity 'Test case - SingleDelegation - PortToPWP - Operation'() { WriteLine("-- Running test case: Single delegation connector - Operation delegated from port to part with port --") ; c = new C() ; c.p.setP(4) ; AssertTrue("Operation call delegated", c.a.b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - SameConnector - PortToPWP - Signal' ; activity 'Test case - MultipleDelegation - SameConnector - PortToPWP - Signal'() { t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - SameConnector - PortToPWP - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Single delegation connector - Multiple links - Signal delegated from port to part with port --") ; AssertTrue("Signal delegated on all links (shall be true for default strategy)", this.c.a[1].b.p == 4 && this.c.a[2].b.p == 4 && this.c.a[3].b.p == 4 && this.c.a[4].b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - SameConnector - PortToPWP - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.c.p.S(4, this) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; this.test() ; } namespace 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPWP - Operation' ; activity 'Test case - MultipleDelegation - MultipleConnectors - PortToPWP - Operation'() { WriteLine("-- Running test case: Multiple delegation connectors - Multiple links - Operation delegated from port to part with port --") ; c = new C() ; c.p.setP(4) ; AssertTrue("Operation call delegated", c.a1.b.p == 4 || c.a2.b.p == 4 || c.a3.b.p == 4 || c.a4.b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - MultipleConnectors - PortToPart - Operation' ; activity 'Test case - MultipleDelegation - MultipleConnectors - PortToPart - Operation'() { WriteLine("-- Running test case: Multiple delegation connectors - Multiple links - Operation delegated from port to part --") ; c = new C() ; c.p.setP(4) ; AssertTrue("Operation call delegated", c.b1.p == 4 || c.b2.p == 4 || c.b3.p == 4 || c.b4.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - SameConnector - PortToPart - Operation' ; activity 'Test case - MultipleDelegation - SameConnector - PortToPart - Operation'() { WriteLine("-- Running test case: Single delegation connector - Multiple links - Operation delegated from port to part --") ; c = new C() ; c.p.setP(4) ; AssertTrue("Operation call delegated", c.b[1].p == 4 || c.b[2].p == 4 || c.b[3].p == 4 || c.b[4].p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - SameConnector - PortToPWP - Operation' ; activity 'Test case - MultipleDelegation - SameConnector - PortToPWP - Operation'() { WriteLine("-- Running test case: Single delegation connector - Multiple links - Operation delegated from port to part with port--") ; c = new C() ; c.p.setP(4) ; AssertTrue("Operation call delegated", c.a[1].b.p == 4 || c.a[2].b.p == 4 || c.a[3].b.p == 4 || c.a[4].b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - MultipleConnectors - PortToPWP - Signal' ; activity 'Test case - MultipleDelegation - MultipleConnectors - PortToPWP - Signal'() { t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - MultipleConnectors - PortToPWP - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Multiple delegation connectors - Multiple links - Signal delegated from port to part with port --") ; AssertTrue("Signal delegated on all links (shall be true for default strategy)", this.c.a1.b.p == 4 && this.c.a2.b.p == 4 && this.c.a3.b.p == 4 && this.c.a4.b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'MultipleDelegation - MultipleConnectors - PortToPWP - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.c.p.S(4, this) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; this.test() ; } Invocation using onPort namespace 'Test Suites'::'Test Suite 3'::Signals::'Test Case - Assembly'::TestCaseAssembly ; private import AssertionLibrary::* ; activity test() { AssertTrue("Signal correctly sent and received", this.a.v == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 3'::Signals::'Test Case - Assembly' ; activity TestCaseBehavior() { WriteLine("-- Running test case - SendSignalAction using onPort - Single assembly connector --") ; testCase = new TestCaseAssembly() ; testCase.tester.Start(testCase) ; } namespace 'Test Suites'::'Test Suite 3'::Signals::'Test Case - Assembly + Delegation'::TestCaseAssemblyAndDelegation ; private import AssertionLibrary::* ; activity test() { WriteLine("-- Running test case - SendSignalAction using onPort - Delegation/Assembly connector chain--") ; AssertTrue("Signal correctly sent and received", this.b.a.v == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 3'::Signals::'Test Case - Assembly + Delegation' ; activity TestCaseBehavior() { testCase = new TestCaseAssemblyAndDelegation() ; testCase.c.tester.Start(testCase) ; } namespace 'Test Suites'::'Test Suite 3' ; private import 'Test Suites'::'Test Suite 3'::Signals::* ; private import 'Test Suites'::'Test Suite 3'::Operation::* ; activity 'Test Suite 3'() { WriteLine("---- Running Test Suite 3 ----") ; WriteLine("") ; 'Test Case - Assembly'::TestCaseBehavior() ; WriteLine("") ; 'Test Case - Assembly + Delegation'::TestCaseBehavior() ; WriteLine("") ; 'Test Case - Feature on Provided Interface'::'Test case - Feature on Provided Interface'() ; WriteLine("") ; 'Test case - Feature on Required Interface'::'Test case - Feature on Required Interface'() ; WriteLine("") ; 'Test case - Feature on Required Interface with Delegation Chain'::'Test case - Feature on Required Interface with Delegation Chain'() ; WriteLine("") ; 'Test case - Feature on both Required and Provided Interface'::'Test case - Feature on both Provided and Required Interface'() ; WriteLine("") ; WriteLine("") ; WriteLine("---- End of Test Suite 3 ----") ; } /* Generated textual representation of Activity Test Suites::Test Suite 3::Operation::B::setP */ namespace 'Test Suites'::'Test Suite 3'::Operation::B ; activity setP(in v : Integer) { this.p = v ; } namespace 'Test Suites'::'Test Suite 3'::Operation::'Test Case - Feature on Provided Interface' ; activity 'Test case - Feature on Provided Interface'() { WriteLine("-- Running test case: Feature on Provided Interface --") ; a = new A() ; a.setP(4) ; AssertTrue("Invocation made into a through q", a.b.p == 4) ; WriteLine("-- End of test case --") ; } is conjugated namespace 'Test Suites'::'Test Suite 3'::Operation::'Test Case - Feature on Provided Interface' ; activity 'Test case - Feature on Required Interface'() { WriteLine("-- Running test case: Feature on Required Interface --") ; d = new D() ; d.c.setP(4) ; AssertTrue("Invocation forwarded out of c through q", d.a.b.p == 4) ; WriteLine("-- End of test case --") ; } is conjugated is conjugated namespace 'Test Suites'::'Test Suite 3'::Operation::'Test case - Feature on Required Interface with Delegation Chain' ; activity 'Test case - Feature on Required Interface with Delegation Chain'() { WriteLine("-- Running test case: Feature on Required Interface with Delegation Chain--") ; d = new D() ; d.e.c.setP(4) ; AssertTrue("Invocation forwarded out of e through q", d.a.b.p == 4) ; WriteLine("-- End of test case --") ; } is conjugated is conjugated namespace 'Test Suites'::'Test Suite 3'::Operation::'Test case - Feature on both Required and Provided Interface' ; activity 'Test case - Feature on both Required and Provided Interface'() { WriteLine("-- Running test case: Feature on both Required and Provided Interface --") ; d = new D() ; d.e.c.setP(4) ; AssertTrue("Invocation forwarded out of e through q", d.a.b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites' ; private import 'Test Suites'::'Test Suite 1'::* ; private import 'Test Suites'::'Test Suite 1 - Bis'::* ; private import 'Test Suites'::'Test Suite 2'::* ; private import 'Test Suites'::'Test Suite 2 - Bis'::* ; private import 'Test Suites'::'Test Suite 2 - Ter'::* ; private import 'Test Suites'::'Test Suite 2 - Quater'::* ; private import 'Test Suites'::'Test Suite 3'::* ; private import 'Test Suites'::'Test Suite 3 - Bis'::* ; private import 'Test Suites'::'Test Suite 3 - Ter'::* ; private import 'Test Suites'::'Test Suite 3 - Quater'::* ; activity 'Run all tests but Test Suite 4'() { 'Test Suite 1'() ; WriteLine("") ; WriteLine("") ; WriteLine("") ; 'Test Suite 1 - Bis'() ; WriteLine("") ; WriteLine("") ; WriteLine("") ; 'Test Suite 2'() ; WriteLine("") ; WriteLine("") ; WriteLine("") ; 'Test Suite 2 - Bis'() ; WriteLine("") ; WriteLine("") ; WriteLine("") ; 'Test Suite 2 - Ter'() ; WriteLine("") ; WriteLine("") ; WriteLine("") ; 'Test Suite 2 - Quater'() ; WriteLine("") ; WriteLine("") ; WriteLine("") ; 'Test Suite 3'() ; WriteLine("") ; WriteLine("") ; WriteLine("") ; 'Test Suite 3 - Bis'() ; WriteLine("") ; WriteLine("") ; WriteLine("") ; 'Test Suite 3 - Ter'() ; WriteLine("") ; WriteLine("") ; WriteLine("") ; 'Test Suite 3 - Quater'() ; } Destruction namespace 'Test Suites'::'Test Suite 4'::'Removing instance from a role' ; private import 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPart - Operation'::* ; activity 'Removing instance from part'() { WriteLine("-- Running test case: Removing instance from a part implies destruction of related links --") ; a = new A() ; b = a.b ; q = a.q ; a.b = null ; AssertTrue("Link has been destroyed", R.x(y => q)->size() == 0 && R.y(x => b)->size() == 0) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 4'::'Removing instance from a role' ; private import 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPart - Operation'::* ; activity 'Removing instance from port'() { WriteLine("-- Running test case: Removing instance from a port implies destruction of related links --") ; a = new A() ; b = a.b ; q = a.q ; a.q = null ; AssertTrue("Link has been destroyed", R.x(y => q)->size() == 0 && R.y(x => b)->size() == 0) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 4'::'Recursive destruction of parts and ports' ; private import 'Test Suites'::'Test Suite 1'::'Assembly_PWP_PWP'::* ; activity TestCaseBehavior() { a = new A_Star_Pattern() ; WriteLine("-- Running Test Case: Recursive destruction of parts and ports --") ; Write("# Instances of B: ") ; Write(B.allInstances()->size()) ; WriteLine("") ; Write("# Instances of C: ") ; Write(C.allInstances()->size()) ; WriteLine("") ; Write("# Instances of IImpl: ") ; Write(IImpl.allInstances()->size()) ; WriteLine("") ; WriteLine("... Destruction of a ...") ; a.destroy() ; AssertTrue("All instances of B recursively destroyed", B.allInstances()->size() == 0) ; AssertTrue("All instances of C recursively destroyed", C.allInstances()->size() == 0) ; AssertTrue("All instances of IImpl recursively destroyed", IImpl.allInstances()->size() == 0) ; WriteLine("-- End of Test Case --") ; } namespace 'Test Suites'::'Test Suite 4' ; activity 'Test Suite 4'() { WriteLine("---- Running Test Suite 4 ----") ; WriteLine("") ; 'Recursive destruction of parts and ports'::TestCaseBehavior() ; WriteLine("") ; 'Removing instance from a role'::'Removing instance from part'() ; WriteLine("") ; 'Removing instance from a role'::'Removing instance from port'() ; WriteLine("") ; WriteLine("") ; WriteLine("---- End of Test Suite 4 ----") ; } Variant with untyped connectors namespace 'Test Suites'::'Test Suite 2 - Bis' ; private import 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPart - Signal'::* ; private import 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPart - Operation'::* ; private import 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPWP - Signal'::* ; private import 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPWP - Operation'::* ; private import 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - SameConnector - PortToPart - Signal'::* ; private import 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - SameConnector - PortToPart - Operation'::* ; private import 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - SameConnector - PortToPWP - Signal'::* ; private import 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - SameConnector - PortToPWP - Operation'::* ; private import 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - MultipleConnectors - PortToPart - Signal'::* ; private import 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - MultipleConnectors - PortToPWP - Signal'::* ; private import 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - MultipleConnectors - PortToPart - Operation'::* ; private import 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - MultipleConnectors - PortToPWP - Operation'::* ; activity 'Test Suite 2 - Bis'() { WriteLine("---- Running Test Suite 2 - Untyped Connectors ----") ; WriteLine("") ; 'Test case - SingleDelegation - PortToPart - Operation'() ; WriteLine("") ; 'Test case - SingleDelegation - PortToPart - Signal'() ; WriteLine("") ; 'Test case - SingleDelegation - PortToPWP - Operation'() ; WriteLine("") ; 'Test case - SingleDelegation - PortToPWP - Signal'() ; WriteLine("") ; 'Test case - MultipleDelegation - MultipleConnectors - PortToPart - Operation'() ; WriteLine("") ; 'Test case - MultipleDelegation - MultipleConnectors - PortToPart - Signal'() ; WriteLine("") ; 'Test case - MultipleDelegation - MultipleConnectors - PortToPWP - Operation'() ; WriteLine("") ; 'Test case - MultipleDelegation - MultipleConnectors - PortToPWP - Signal'() ; WriteLine("") ; 'Test case - MultipleDelegation - SameConnector - PortToPart - Operation'() ; WriteLine("") ; 'Test case - MultipleDelegation - SameConnector - PortToPart - Signal'() ; WriteLine("") ; 'Test case - MultipleDelegation - SameConnector - PortToPWP - Operation'() ; WriteLine("") ; 'Test case - MultipleDelegation - SameConnector - PortToPWP - Signal'() ; WriteLine("") ; WriteLine("") ; WriteLine("---- End of Test Suite 2 - Untyped Connectors ----") ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPart - Signal' ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::AbstractTester ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Start ; activity 'Test case - SingleDelegation - PortToPart - Signal'() { AbstractTester t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPart - Signal'::B ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::S ; activity BClassifierBehavior() { accept (s : S) { this.p = s.v ; s.t.Continue() ; } } namespace 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPart - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Single delegation connector - Signal delegated from port to part --") ; AssertTrue("Signal delegated to classifier behavior", this.a.b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPart - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.a.q.S(4, this) ; accept(Continue) ; this.test() ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPart - Operation' ; activity 'Test case - SingleDelegation - PortToPart - Operation'() { WriteLine("-- Running test case: Single delegation connector - Operation delegated from port to part --") ; // Instantiate A a = new A() ; a.q.setP(4) ; AssertTrue("Operation call delegated", a.b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2'::'SingleDelegation - PortToPart - Operation'::B ; activity BClassifierBehavior() { // FIXME: This classifier behavior shall not exist. To be removed when Alf to fUML compiler is patched. } namespace 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPart - Operation'::B ; activity setP(in v : Integer) { this.p = v ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - SameConnector - PortToPart - Signal' ; activity 'Test case - MultipleDelegation - SameConnector - PortToPart - Signal'() { t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - SameConnector - PortToPart - Signal'::B ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::S ; activity BClassifierBehavior() { accept (s : S) { this.p = s.v ; s.t.Continue() ; } } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - SameConnector - PortToPart - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Single delegation connector - Multiple links - Signal delegated from port to part --") ; AssertTrue("Signal delegated on all links (shall be true for default strategy)", this.a.b[1].p == 4 && this.a.b[2].p == 4 && this.a.b[3].p == 4 && this.a.b[4].p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - SameConnector - PortToPart - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.a.q.S(4, this) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; this.test() ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - MultipleConnectors - PortToPart - Signal' ; activity 'Test case - MultipleDelegation - MultipleConnectors - PortToPart - Signal'() { t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - MultipleConnectors - PortToPart - Signal'::B ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::S ; activity BClassifierBehavior() { accept (s : S) { this.p = s.v ; s.t.Continue() ; } } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - MultipleConnectors - PortToPart - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Multiple delegation connectors - Multiple links - Signal delegated from port to part --") ; AssertTrue("Signal delegated on all links (shall be true for default strategy)", this.a.b1.p == 4 && this.a.b2.p == 4 && this.a.b3.p == 4 && this.a.b4.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - MultipleConnectors - PortToPart - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.a.q.S(4, this) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; this.test() ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPWP - Signal' ; //private import 'Test Suites'::'Test Suite 2'::'BehaviorPort - Signal'::Start ; activity 'Test case - SingleDelegation - PortToPWP - Signal'() { t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPWP - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Single delegation connector - Signal delegated from port to part with port --") ; AssertTrue("Signal delegated", this.c.a.b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPWP - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.c.p.S(4, this) ; accept(Continue) ; this.test() ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPWP - Operation' ; activity 'Test case - SingleDelegation - PortToPWP - Operation'() { WriteLine("-- Running test case: Single delegation connector - Operation delegated from port to part with port --") ; c = new C() ; c.p.setP(4) ; AssertTrue("Operation call delegated", c.a.b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - SameConnector - PortToPWP - Signal' ; activity 'Test case - MultipleDelegation - SameConnector - PortToPWP - Signal'() { t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - SameConnector - PortToPWP - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Single delegation connector - Multiple links - Signal delegated from port to part with port --") ; AssertTrue("Signal delegated on all links (shall be true for default strategy)", this.c.a[1].b.p == 4 && this.c.a[2].b.p == 4 && this.c.a[3].b.p == 4 && this.c.a[4].b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - SameConnector - PortToPWP - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.c.p.S(4, this) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; this.test() ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'SingleDelegation - PortToPWP - Operation' ; activity 'Test case - MultipleDelegation - MultipleConnectors - PortToPWP - Operation'() { WriteLine("-- Running test case: Multiple delegation connectors - Multiple links - Operation delegated from port to part with port --") ; c = new C() ; c.p.setP(4) ; AssertTrue("Operation call delegated", c.a1.b.p == 4 || c.a2.b.p == 4 || c.a3.b.p == 4 || c.a4.b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - MultipleConnectors - PortToPart - Operation' ; activity 'Test case - MultipleDelegation - MultipleConnectors - PortToPart - Operation'() { WriteLine("-- Running test case: Multiple delegation connectors - Multiple links - Operation delegated from port to part --") ; c = new C() ; c.p.setP(4) ; AssertTrue("Operation call delegated", c.b1.p == 4 || c.b2.p == 4 || c.b3.p == 4 || c.b4.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - SameConnector - PortToPart - Operation' ; activity 'Test case - MultipleDelegation - SameConnector - PortToPart - Operation'() { WriteLine("-- Running test case: Single delegation connector - Multiple links - Operation delegated from port to part --") ; c = new C() ; c.p.setP(4) ; AssertTrue("Operation call delegated", c.b[1].p == 4 || c.b[2].p == 4 || c.b[3].p == 4 || c.b[4].p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - SameConnector - PortToPWP - Operation' ; activity 'Test case - MultipleDelegation - SameConnector - PortToPWP - Operation'() { WriteLine("-- Running test case: Single delegation connector - Multiple links - Operation delegated from port to part with port--") ; c = new C() ; c.p.setP(4) ; AssertTrue("Operation call delegated", c.a[1].b.p == 4 || c.a[2].b.p == 4 || c.a[3].b.p == 4 || c.a[4].b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - MultipleConnectors - PortToPWP - Signal' ; activity 'Test case - MultipleDelegation - MultipleConnectors - PortToPWP - Signal'() { t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - MultipleConnectors - PortToPWP - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Multiple delegation connectors - Multiple links - Signal delegated from port to part with port --") ; AssertTrue("Signal delegated on all links (shall be true for default strategy)", this.c.a1.b.p == 4 && this.c.a2.b.p == 4 && this.c.a3.b.p == 4 && this.c.a4.b.p == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'MultipleDelegation - MultipleConnectors - PortToPWP - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.c.p.S(4, this) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; accept(Continue) ; this.test() ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::A ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::S ; activity AClassifierBehavior() { accept (s : S) { this.p = s.v ; s.t.Continue() ; } } namespace 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal' ; activity 'Test case - BehaviorPort - Signal'() { // Instantiate Tester t = new Tester() ; t.Start() ; } namespace 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Tester ; activity test() { WriteLine("-- Running test case: Reception of a Signal on a behavior port --") ; AssertTrue("Signal delegated to classifier behavior", this.a.p == 4) ; WriteLine("-- End of test case --") ; } /* Generated textual representation of Activity Test Suites::Test Suite 2::BehaviorPort - Signal::Tester::TesterClassifierBehavior */ namespace 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Tester ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Start ; private import 'Test Suites'::'Test Suite 2 - Bis'::'BehaviorPort - Signal'::Continue ; activity TesterClassifierBehavior() { accept(Start) ; this.a.q.S(4, this) ; accept(Continue) ; this.test() ; } Variant with untyped connectors namespace 'Test Suites'::'Test Suite 3 - Bis'::Signals::'Test Case - Assembly'::TestCaseAssembly ; private import AssertionLibrary::* ; activity test() { AssertTrue("Signal correctly sent and received", this.a.v == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 3 - Bis'::Signals::'Test Case - Assembly' ; activity TestCaseBehavior() { WriteLine("-- Running test case - SendSignalAction using onPort - Single assembly connector --") ; testCase = new TestCaseAssembly() ; testCase.tester.Start(testCase) ; } namespace 'Test Suites'::'Test Suite 3 - Bis'::Signals::'Test Case - Assembly + Delegation'::TestCaseAssemblyAndDelegation ; private import AssertionLibrary::* ; activity test() { WriteLine("-- Running test case - SendSignalAction using onPort - Delegation/Assembly connector chain--") ; AssertTrue("Signal correctly sent and received", this.b.a.v == 4) ; WriteLine("-- End of test case --") ; } namespace 'Test Suites'::'Test Suite 3 - Bis'::Signals::'Test Case - Assembly + Delegation' ; activity TestCaseBehavior() { testCase = new TestCaseAssemblyAndDelegation() ; testCase.c.tester.Start(testCase) ; } namespace 'Test Suites'::'Test Suite 3 - Bis' ; private import 'Test Suites'::'Test Suite 3 - Bis'::Signals::* ; private import 'Test Suites'::'Test Suite 3 - Bis'::Operation::* ; activity 'Test Suite 3 - Bis'() { WriteLine("---- Running Test Suite 3 - Untyped Connectors ----") ; WriteLine("") ; 'Test Case - Assembly'::TestCaseBehavior() ; WriteLine("") ; 'Test Case - Assembly + Delegation'::TestCaseBehavior() ; WriteLine("") ; 'Test Case - Feature on Provided Interface'::'Test case - Feature on Provided Interface'() ; WriteLine("") ; 'Test case - Feature on Required Interface'::'Test case - Feature on Required Interface'() ; WriteLine("") ; 'Test case - Feature on Required Interface with Delegation Chain'::'Test case - Feature on Required Interface with Delegation Chain'() ; WriteLine("") ; 'Test case - Feature on both Required and Provided Interface'::'Test case - Feature on both Provided and Required Interface'() ; WriteLine("") ; WriteLine("") ; WriteLine("---- End of Test Suite 3 - Untyped Connectors ----") ; } /* Generated textual representation of Activity Test Suites::Test Suite 3::Operation::B::setP */ namespace 'Test Suites'::'Test Suite 3 - Bis'::Operation::B ; activity setP(in v : Integer) { this.p = v ; } namespace 'Test Suites'::'Test Suite 3 - Bis'::Operation::'Test Case - Feature on Provided Interface' ; activity 'Test case - Feature on Provided Interface'() { WriteLine("-- Running test case: Feature on Provided Interface --") ; a = new A() ; a.setP(4) ; AssertTrue("Invocation made into a through q", a.b.p == 4) ; WriteLine("-- End of test case --") ; } is conjugated namespace 'Test Suites'::'Test Suite 3 - Bis'::Operation::'Test Case - Feature on Provided Interface' ; activity 'Test case - Feature on Required Interface'() { WriteLine("-- Running test case: Feature on Required Interface --") ; d = new D() ; d.c.setP(4) ; AssertTrue("Invocation forwarded out of c through q", d.a.b.p == 4) ; WriteLine("-- End of test case --") ; } is conjugated is conjugated namespace 'Test Suites'::'Test Suite 3 - Bis'::Operation::'Test case - Feature on Required Interface with Delegation Chain' ; activity 'Test case - Feature on Required Interface with Delegation Chain'() { WriteLine("-- Running test case: Feature on Required Interface with Delegation Chain--") ; d = new D() ; d.e.c.setP(4) ; AssertTrue("Invocation forwarded out of e through q", d.a.b.p == 4) ; WriteLine("-- End of test case --") ; } is conjugated is conjugated namespace 'Test Suites'::'Test Suite 3 - Bis'::Operation::'Test case - Feature on both Required and Provided Interface' ; activity 'Test case - Feature on both Required and Provided Interface'() { WriteLine("-- Running test case: Feature on both Required and Provided Interface --") ; d = new D() ; d.e.c.setP(4) ; AssertTrue("Invocation forwarded out of e through q", d.a.b.p == 4) ; WriteLine("-- End of test case --") ; } Variant with ports typed by Interfaces namespace 'Test Suites'::'Test Suite 1 - Bis' ; private import 'Test Suites'::'Test Suite 1 - Bis'::Assembly_PWP_P::* ; private import 'Test Suites'::'Test Suite 1 - Bis'::Assembly_PWP_PWP::* ; private import 'Test Suites'::'Test Suite 1 - Bis'::Delegation_Port_P::* ; private import 'Test Suites'::'Test Suite 1 - Bis'::Delegation_Port_PWP::* ; /** * Runs all test cases defined in Test Suite 1 - Bis */ activity 'Test Suite 1 - Bis'() { WriteLine("---- Running Test Suite 1 - Bis: Ports typed by Interfaces ----") ; WriteLine("") ; TestCase_Assembly_PWP_P () ; WriteLine("") ; TestCase_Assembly_PWP_PWP () ; WriteLine("") ; TestCase_Delegation_Port_P () ; WriteLine("") ; TestCase_Delegation_Port_PWP () ; WriteLine("") ; WriteLine("") ; WriteLine("---- End of Test Suite 1 - Bis----") ; } activity Construct() : B{ // Instantiates interaction points for (i in 1..2) { this.p -> add(new IImpl()) ; } return this ; } namespace 'Test Suites'::'Test Suite 1 - Bis'::Assembly_PWP_P ; private import 'Test Suites'::Utils::* ; activity TestCase_Assembly_PWP_P() { helper = new AssertCompositeHelper() ; WriteLine("-- Running test case: Assembly connector between a part with port and a part -- Ports typed by Interfaces") ; // Testing instantiation of A_Empty_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Empty_Pattern -") ; a_empty = new A_Empty_Pattern() ; AssertEmptyPattern(a_empty.b, a_empty.c) ; // Testing instantiation of A_Unconnected_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Unconnected_Pattern -") ; a_unconnected = new A_Unconnected_Pattern(); AssertUnconnectedPattern(a_unconnected.b.p, a_unconnected.c, 4, 3, helper) ; // Testing instantiation of A_Array_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Array_Pattern -") ; a_array = new A_Array_Pattern(); AssertArrayPattern(a_array.b.p, a_array.c, 4, helper) ; // Testing instantiation of A_Star_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Star_Pattern -") ; a_star = new A_Star_Pattern(); AssertStarPattern(a_star.b.p, a_star.c, 4, 5, helper) ; } Empty pattern: lower bound of part b and c is 0 Array pattern: lower bound of b and c are equals lower bound on ends of connector r is 1 Star pattern: lower bound on ends of connector r equal lower bound of connected parts IntegerFunctions::Min('#ends1', n1) ; namespace 'Test Suites'::'Test Suite 1 - Bis'::Assembly_PWP_P::AssertCompositeHelper ; private import Alf::Library::CollectionFunctions::includes ; activity assertConnected(in message : String, in end1 : any, in end2 : any) { AssertTrue(message, R::y((I)end1)->includes((C)end2)) ; } namespace 'Test Suites'::'Test Suite 1 - Bis'::Assembly_PWP_P::AssertCompositeHelper ; private import Alf::Library::CollectionFunctions::includes ; activity assertNodeConnected_method(in message : String, in end1 : any, in end2 : any) { AssertTrue(message, ! R::y((I)end1)->includes((C)end2)) ; } Unconnected pattern: lower bound on ends of connector r is 0 namespace 'Test Suites'::'Test Suite 1 - Bis'::Assembly_PWP_PWP ; private import 'Test Suites'::Utils::* ; activity TestCase_Assembly_PWP_PWP () { helper = new AssertCompositeHelper() ; WriteLine("-- Running test case: Assembly connector between a part with port and a part with port -- Ports typed by Interfaces") ; // Testing instantiation of A_Empty_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Empty_Pattern -") ; a_empty = new A_Empty_Pattern() ; AssertEmptyPattern(a_empty.b, a_empty.c) ; // Testing instantiation of A_Unconnected_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Unconnected_Pattern -") ; a_unconnected = new A_Unconnected_Pattern(); AssertUnconnectedPattern(a_unconnected.b.p, a_unconnected.c.q, 4, 3, helper) ; // Testing instantiation of A_Array_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Array_Pattern -") ; a_array = new A_Array_Pattern(); AssertArrayPattern(a_array.b.p, a_array.c.q, 4, helper) ; // Testing instantiation of A_Star_Pattern WriteLine("") ; WriteLine("- Testing instantiation of A_Star_Pattern -") ; a_star = new A_Star_Pattern(); AssertStarPattern(a_star.b.p, a_star.c.q, 4, 5, helper) ; }