RoomModel DynamicActorTest7 {

	import room.basic.etunit.* from "Tests.room"
	import room.basic.types.* from "Types.room"

	LogicalSystem JavaGenTests {
		SubSystemRef da7Test : SubSystem_DynamicActorTest7
	}
	
	SubSystemClass SubSystem_DynamicActorTest7 {
		ActorRef main : Appl
	
		LogicalThread defaultThread
	}

	ActorClass Appl {
		Structure {
			ActorRef cont: Container
		}
		Behavior { }
	}

	ActorClass Container {
		Structure {
			usercode1 {
				"import java.io.File;"
			}
			usercode2 {
				"private static final String FIRST_OPT_OBJ = \"firstOpt.obj\";"
				"private static final String SECOND_OPT_OBJ = \"secondOpt.obj\";"
			}
			conjugated Port op: PStep
			conjugated Port opa [*]: PStep
			
			Attribute caseId: int32
			
			optional ActorRef opt: Optional
			optional ActorRef optarr [*]: Optional
			
			Binding op and opt.fct
			Binding opa and optarr.fct
		}
		Behavior {
			ctor {
				"caseId = etUnit_openAll(\"log/testlog\", \"DynamicActorTest7\", \"org.eclipse.etrice.generator.common.tests.DynamicActorTest7\", \"DynamicActorTest7_case\");"
			}
			dtor {
				"etUnit_closeAll(caseId);"
			}
			Operation clean() {
				"File f = new File(FIRST_OPT_OBJ);"
				"if (f.exists())"
				"\tf.delete();"
			}
			StateMachine {
				Transition init: initial -> Init { }
				Transition tr0: Init -> DestroyAndCreate {
					triggers {
						<hello: op>
					}
					action {
						"System.out.println(\"received \"+transitionData);"
					}
				}
				Transition tr1: DestroyAndCreate -> DestroyAndRestore {
					triggers {
						<hello: op>
					}
					action {
						"System.out.println(\"received \"+transitionData);"
					}
				}
				Transition tr2: DestroyAndRestore -> LoadInArray {
					triggers {
						<hello: op>
					}
					action {
						"System.out.println(\"received \"+transitionData);"
					}
				}
				Transition tr3: LoadInArray -> ReceivedHello {
					triggers {
						<hello: opa>
					}
					action {
						"System.out.println(\"received \"+transitionData);"
					}
				}
				Transition tr4: ReceivedHello -> Done {
					triggers {
						<hello: opa>
					}
					action {
						"System.out.println(\"received \"+transitionData);"
					}
				}
				State Init {
					entry {
						"clean();"
						"FilePersistor.createAndLoad(opt, getThread(), FIRST_OPT_OBJ, \"Optional1\");"
						"op.step();"
						"op.step();"
						"op.sayHello();"
					}
				}
				State DestroyAndCreate {
					entry {
						"FilePersistor.saveAndDestroy(opt, FIRST_OPT_OBJ);"
						"FilePersistor.createAndLoad(opt, getThread(), SECOND_OPT_OBJ, \"Optional2\");"
						"op.step();"
						"op.step();"
						"op.sayHello();"
					}
				}
				State DestroyAndRestore {
					entry {
						"FilePersistor.saveAndDestroy(opt, SECOND_OPT_OBJ);"
						"FilePersistor.createAndLoad(opt, getThread(), FIRST_OPT_OBJ, \"Optional1\");"
						"op.sayHello();"
					}
				}
				State Done {
					entry {
						"IRTObject object = getObject(\"/JavaGenTests/da7Test/main/cont/optarr/optarr:0/sub\");"
						"EXPECT_TRUE(caseId, \"object 0 of optarr is an instance of actor class Sub1\", object instanceof Sub1);"
						""
						"Sub1 inst = (Sub1) object;"
						"EXPECT_EQUAL_INT32(caseId, \"state\", Sub1.STATE_Step3_StepA, inst.getState());"
						"EXPECT_EQUAL_INT32(caseId, \"current value of ival\", 123, inst.getIval());"
						"EXPECT_EQUAL_INT16(caseId, \"current value of sval\", (short)456, inst.getSval());"
						"EXPECT_EQUAL_INT8(caseId, \"current value of bval\", (byte)3, inst.getBval());"
						"EXPECT_TRUE(caseId, \"changed string\", \"changed\".equals(inst.getSome()[1].getStr()));"
						"EXPECT_EQUAL_FLOAT32(caseId, \"current vaue of\", 3.14159f, inst.getDerived().getSome().getFval()[2], 0.001f);"
						"EXPECT_EQUAL_UINT8(caseId, \"current value of cval\", 'x', inst.getCval());"
						""
						"etUnit_testFinished(caseId);"
					}
				}
				State LoadInArray {
					entry {
						"FilePersistor.createAndLoad(optarr, getThread(), FIRST_OPT_OBJ, \"Optional1\");"
						"FilePersistor.createAndLoad(optarr, getThread(), SECOND_OPT_OBJ, \"Optional2\");"
						"opa.sayHello();"
					}
				}
				State ReceivedHello
			}
		}
	}

	abstract ActorClass Optional {
		Interface {
			Port fct: PStep
		}
		Structure { }
		Behavior { }
	}

	ActorClass Optional1 extends Optional {
		Structure {
			ActorRef ^sub: Sub1
			Binding fct and ^sub.fct
		}
		Behavior { }
	}

	ActorClass Optional2 extends Optional {
		Structure {
			ActorRef ^sub: Sub2
			Binding fct and ^sub.fct
		}
		Behavior { }
	}

	ActorClass Sub1Base {
		Structure {
			Attribute cval: char
		}
	}
	
	ActorClass Sub1 extends Sub1Base {
		Interface {
			Port fct: PStep
		}
		Structure {
			external Port fct
			conjugated Port dp: PStep
			
			Attribute ival: int32
			Attribute sval: int16
			Attribute bval: int8
			Attribute some[3]: SomeData
			Attribute other: OtherData
			Attribute derived: DerivedData
			
			ActorRef deep: DeepSub1
			Binding dp and deep.fct
		}
		Behavior {
			StateMachine {
				Transition init: initial -> Step1 { }
				Transition tr0: Step1 -> Step2 {
					triggers {
						<step: fct>
					}
					action {
						"dp.step();"
					}
				}
				Transition tr1: Step2 -> Step3 {
					triggers {
						<step: fct>
					}
					action {
						"dp.step();"
					}
				}
				Transition tr2: my tp0 -> my tp0 {
					triggers {
						<sayHello: fct>
					}
					action {
						"fct.hello(getClassName()+\", state=\"+stateStrings[getState()]+\", path= \"+getInstancePath());"
					}
				}
				handler TransitionPoint tp0
				State Step1 {
					entry {
						"ival = 1;"
						"sval = 2;"
						"bval = 3;"
						"cval = 'x';"
					}
				}
				State Step2 {
					entry {
						"ival = 123;"
						"some[1].str = \"changed\";"
						"derived.some.fval[2] = 3.14159f;"
					}
				}
				State Step3 {
					subgraph {
						Transition init: initial -> StepA { }
						Transition tr0: StepA -> StepB {
							triggers {
								<step: fct>
							}
							action {
								"dp.step();"
							}
						}
						Transition tr1: StepB -> StepC {
							triggers {
								<step: fct>
							}
							action {
								"dp.step();"
							}
						}
						State StepA {
							entry {
								"sval = 456;"
							}
						}
						State StepB {
							entry {
								"bval = 13;"
							}
						}
						State StepC
					}
				}
			}
		}
	}

	ActorClass DeepSub1 {
		Interface {
			Port fct: PStep
		}
		Structure {
			external Port fct
		}
		Behavior {
			StateMachine {
				Transition init: initial -> Step1 { }
				Transition tr0: Step1 -> Step2 {
					triggers {
						<step: fct>
					}
				}
				Transition tr1: Step2 -> Step3 {
					triggers {
						<step: fct>
					}
				}
				Transition tr2: Step3 -> Step5 {
					triggers {
						<step: fct>
					}
				}
				Transition tr3: Step5 -> Step6 {
					triggers {
						<step: fct>
					}
				}
				Transition tr4: Step6 -> Step7 {
					triggers {
						<step: fct>
					}
				}
				State Step1
				State Step2
				State Step3
				State Step5
				State Step6
				State Step7
			}
		}
	}

	ActorClass Sub2 {
		Interface {
			Port fct: PStep
		}
		Structure {
			external Port fct
		}
		Behavior {
			StateMachine {
				Transition init: initial -> Ready { }
				Transition tr0: Ready -> Ready {
					triggers {
						<step: fct>
					}
				}
				Transition tr1: Ready -> Ready {
					triggers {
						<sayHello: fct>
					}
					action {
						"fct.hello(getClassName()+\", state=\"+stateStrings[getState()]+\", path= \"+getInstancePath());"
					}
				}
				State Ready
			}
		}
	}

	ProtocolClass PStep {
		incoming {
			Message step()
			Message sayHello()
		}
		outgoing {
			Message hello(txt: string)
		}
	}

	DataClass SomeData {
		Attribute fval[3]: float32 = "1.0"
		Attribute dval: float64 = "123.4"
		Attribute str: string = "\"Text\""
	}
	
	DataClass OtherData {
		Attribute some: SomeData
		Attribute bval: boolean = "false"
	}
	
	DataClass DerivedData extends OtherData {
		Attribute cval[3]: char = "{'a', 'b', 'c'}"
	}
}