/******************************************************************************
 * Copyright (c) 2000-2016 Ericsson Telecom AB
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Balasko, Jeno
 *   Dimitrov, Peter
 *   Feher, Csaba
 *   Harai, Tibor
 *   Raduly, Csaba
 *   Szabados, Kristof
 *   Szabo, Janos Zoltan – initial implementation
 *
 ******************************************************************************/
module TconfigOper {

type port configOper_port1 message
{ inout integer } with { extension "internal" };

// A "black hole" port.
type port configOper_port2 message {
 inout charstring;
 }

type component configOper_comp1 {
 port configOper_port1 Port1;
 var integer xx1;
 };

type component configOper_comp2 {
 port configOper_port1 Port2[5];
 var integer xx2;
 };

type component configOper_comp4 {
 port configOper_port2 Port4;
 }

type component configOper_comp5 { 
  port configOper_port1 P, Q, R;
  timer T := 1.0;
}

function configOper_behav0() runs on configOper_comp1 {
timer T:=1.0; // doing nothing, alt is needed for "stop"
while (true) {
  T.start;
  alt
   { [] T.timeout {T.start}   }
  };
};

function configOper_behav1() runs on configOper_comp1 {
		//sends back x+1
Port1.receive(integer:?) -> value xx1;
xx1:=xx1+1;
Port1.send(xx1);
};

function configOper_behav2() runs on configOper_comp1 {
		//sends back x+2
Port1.receive(integer:?) -> value xx1;
xx1:=xx1+2;
Port1.send(xx1);
};

function configOper_behav3() runs on configOper_comp1 {
timer TT:=1.0;
		//if receives anything -> stops
Port1.receive(integer:?);
TT.start;
alt
 { [] Port1.receive(integer:?) { action("configOper_behav3 received the integer after ", TT.read, " seconds");};
   [] TT.timeout { action("configOper_behav3 timed out"); stop; } };
};

testcase configOperRunning1() runs on configOper_comp1 {
var configOper_comp1 comp:=configOper_comp1.create;
comp.start(configOper_behav0());
if (comp.running) {setverdict(pass)}
  else {setverdict(fail)};
comp.stop;
};

testcase configOperRunning2() runs on configOper_comp1 {
var configOper_comp1 comp:=configOper_comp1.create;
comp.start(configOper_behav0());
comp.stop;
if (comp.running) {setverdict(fail)}
  else {setverdict(pass)};
};

testcase configOperConnectMtc() runs on configOper_comp1 {
var configOper_comp1 comp:=configOper_comp1.create;
connect(mtc:Port1,comp:Port1);
comp.start(configOper_behav1());
xx1:=5;
Port1.send(xx1);
Port1.receive(integer:?) -> value xx1;
if (xx1==6) {setverdict(pass)}
  else {setverdict(fail)};
comp.stop;
};

testcase configOperConnectSelf() runs on configOper_comp1 {
var configOper_comp1 comp:=configOper_comp1.create;
connect(self:Port1,comp:Port1);
comp.start(configOper_behav1());
xx1:=5;
Port1.send(xx1);
Port1.receive(integer:?) -> value xx1;
if (xx1==6) {setverdict(pass)}
  else {setverdict(fail)};
comp.stop;
};

testcase configOperDisconnect() runs on configOper_comp1 {
var configOper_comp1 comp1:=configOper_comp1.create;
var configOper_comp1 comp2:=configOper_comp1.create;
comp1.start(configOper_behav1());
comp2.start(configOper_behav2());
connect(self:Port1,comp1:Port1);
disconnect(self:Port1,comp1:Port1);
connect(self:Port1,comp2:Port1);
xx1:=5;
Port1.send(xx1);
Port1.receive(integer:?) -> value xx1;
if (xx1==7) {setverdict(pass)}
  else {setverdict(fail)};
comp1.stop;
comp2.stop;
};

testcase configOperDone() runs on configOper_comp1 {
var configOper_comp1 comp:=configOper_comp1.create;
timer T1:=10.0;
connect(self:Port1,comp:Port1);
comp.start(configOper_behav3());
xx1:=5;
Port1.send(xx1);
T1.start;
alt {
 [] Port1.receive(integer:?) -> value xx1 {setverdict(fail)}
 [] comp.done {setverdict(pass)}
 [] T1.timeout {setverdict(fail)}
}
};

testcase configOperArray() runs on configOper_comp2 {
var configOper_comp1 comp[5];
var integer i;
xx2:=5;
for (i:=0; i<5; i:=i+1)
{ comp[i]:=configOper_comp1.create;
  connect(self:Port2[i],comp[i]:Port1);
  comp[i].start(configOper_behav1());
  Port2[i].send(xx2);
  Port2[i].receive(integer:?) -> value xx2;
  if (xx2==i+6) {setverdict(pass)}
    else {setverdict(fail)};
}
for (i:=5; i<5; i:=i+1) {comp[i].stop};
};

testcase configOperRunningAny() runs on configOper_comp2 {
var configOper_comp1 comp[5];
var integer i;
xx2:=5;
for (i:=0; i<5; i:=i+1)
{ comp[i]:=configOper_comp1.create;
  comp[i].start(configOper_behav0());
}
for (i:=0; i<4; i:=i+1)
{ comp[i].stop;
  if (any component.running) {setverdict(pass)}
    else {setverdict(fail)};
}
comp[4].stop;
if (any component.running) {setverdict(fail)}
  else {setverdict(pass)};
};

testcase configOperRunningAll() runs on configOper_comp2 {
var configOper_comp1 comp[5];
var integer i;
xx2:=5;
for (i:=0; i<5; i:=i+1)
{ comp[i]:=configOper_comp1.create;
  comp[i].start(configOper_behav0());
}
if (all component.running) {setverdict(pass)}
  else {setverdict(fail)};
for (i:=0; i<5; i:=i+1)
{ comp[i].stop;
  if (all component.running) {setverdict(pass)}
    else {setverdict(fail)};
}
};

testcase configOperDoneAny() runs on configOper_comp2 {
  var configOper_comp1 comp[5];
  var integer i;
  timer T1:=2.0;
  xx2:=5;
  for (i:=0; i<5; i:=i+1)
  { comp[i]:=configOper_comp1.create;
    connect(self:Port2[i],comp[i]:Port1);
    comp[i].start(configOper_behav3());
  }
  for (i:=0; i<5; i:=i+1) {
    Port2[i].send(xx2);
  }

  T1.start;
  T1.stop;

    alt {
      [] any component.done {setverdict(pass)}
      [] T1.timeout {setverdict(fail)}
    }

};

testcase configOperDoneAny2() runs on configOper_comp2 {
  var configOper_comp1 ptc;
  timer T1 := 1.0;
  T1.start;
  alt {
  [] any component.done { setverdict(fail); }
  [] T1.timeout { setverdict(pass); }
  }
  ptc := configOper_comp1.create;
  T1.start;
  alt {
  [] any component.done { setverdict(fail); }
  [] T1.timeout { setverdict(pass); }
  }
  ptc.stop;
  T1.start;
  alt {
  [] any component.done { setverdict(pass); }
  [] T1.timeout { setverdict(fail); }
  }
}

testcase configOperDoneAny3() runs on configOper_comp2 {
  var configOper_comp1 ptc := configOper_comp1.create;
  timer T1 := 1.0;
  ptc.kill;
  T1.start;
  alt {
  [] any component.done { setverdict(pass); }
  [] T1.timeout { setverdict(fail); }
  }
}

testcase configOperDoneAll() runs on configOper_comp2 {
var configOper_comp1 comp[5];
var integer i;
timer T1:=2.0;
xx2:=5;
log("xx");
for (i:=0; i<5; i:=i+1)
{ log(i);
  comp[i]:=configOper_comp1.create;
  connect(self:Port2[i],comp[i]:Port1);
  comp[i].start(configOper_behav3());
 }
for (i:=0; i<5; i:=i+1) {
  log(i);
  Port2[i].send(xx2);
 }
T1.start;
  alt {
    [] Port2[2].receive(integer:?) {setverdict(fail)}
    [] all component.done {setverdict(pass)}
    [] T1.timeout {setverdict(fail)}
       }
};

testcase configOperStopAll() runs on configOper_comp2 {
var configOper_comp1 comp[5];
var integer i;
//timer T1:=2.0;
//xx2:=5;
for (i:=0; i<5; i:=i+1)
{ log(i);
  comp[i]:=configOper_comp1.create;
  log("z");
  connect(self:Port2[i],comp[i]:Port1);
  comp[i].start(configOper_behav3());
  Port2[i].start;
 }
all component.stop;
if (any component.running) {setverdict(fail)}
    else {setverdict(pass)};
}

testcase configOperAutostop1() runs on configOper_comp2 {
var configOper_comp1 comp[5];
var integer i;
timer T1:=2.0;
xx2:=5;
for (i:=0; i<5; i:=i+1)
{ comp[i]:=configOper_comp1.create;
  connect(self:Port2[i],comp[i]:Port1);
  comp[i].start(configOper_behav1());
  Port2[i].send(xx2);
 }
all component.done;
setverdict(pass);
};

testcase configOperAutostop2() runs on configOper_comp2 {
var configOper_comp1 comp[5];
var integer i;
timer T1:=2.0;
xx2:=5;
for (i:=0; i<5; i:=i+1)
{ comp[i]:=configOper_comp1.create;
  connect(self:Port2[i],comp[i]:Port1);
  comp[i].start(configOper_behav1());
 }
for (i:=0; i<5; i:=i+1)
{ Port2[i].send(xx2);
  Port2[i].receive(integer:?) -> value xx2;
  if (xx2==i+6) {setverdict(pass)}
    else {setverdict(fail)};
}
for (i:=5; i<5; i:=i+1) {comp[i].done};
};

type component configOper_comp3 {
    port configOper_port1 Port3[5];
    var integer xx1;
};

function configOper_behav4() runs on configOper_comp1 {
    Port1.receive(integer:?) -> value xx1;
    xx1:=xx1+1;
};

function configOper_behav5() runs on configOper_comp1 {
    xx1:=xx1+200;
};

function configOper_behav6() runs on configOper_comp1 {
    xx1:=xx1+2;
    Port1.send(xx1);
};

function configOper_behav7(float par) runs on configOper_comp1 {
    timer T:=par;
    T.start;
    T.timeout;
};

testcase configOperRunningAlive_alive() runs on configOper_comp1 {
    var configOper_comp1 comp:=configOper_comp1.create alive;
    comp.start(configOper_behav0());
    if (comp.running and comp.alive)
        {setverdict(pass)}
    else
        {setverdict(fail)};
    comp.kill;
};

testcase configOperRunningAliveKill_alive() runs on configOper_comp1 {
    var configOper_comp1 comp:=configOper_comp1.create alive;
    comp.start(configOper_behav0());
    comp.stop;
    if (comp.running) {setverdict(fail)}
    else {setverdict(pass)};
    if (comp.alive) {setverdict(pass)}
    else {setverdict(fail)};

    comp.kill;
    if (comp.alive) {setverdict(fail)}
    else {setverdict(pass)};
};

testcase configOperRunningAliveKillMixed_alive() runs on configOper_comp1 {
    var configOper_comp1 comp :=configOper_comp1.create alive;
    var configOper_comp1 comp1:=configOper_comp1.create alive;
    var configOper_comp1 comp2:=configOper_comp1.create alive;
    comp.start(configOper_behav0());
    comp1.start(configOper_behav0());
    comp2.start(configOper_behav0());
    if (all component.running) {setverdict(pass)}
    else {setverdict(fail)};

    comp.stop;
    comp1.stop;
    comp2.stop;
    if (any component.running) {setverdict(fail)}
    else {setverdict(pass)};
    if (all component.alive) {setverdict(pass)}
    else {setverdict(fail)};

    comp.kill;
    if (all component.alive) {setverdict(fail)}
    else {setverdict(pass)};
    if (any component.alive) {setverdict(pass)}
    else {setverdict(fail)};

    all component.kill;
    if (any component.alive) {setverdict(fail)}
    else {setverdict(pass)};
};

testcase configOperRunningAliveKillKilledMixed_alive() runs on configOper_comp1 {
    var configOper_comp1 comp :=configOper_comp1.create ("comp alive") alive;
    var configOper_comp1 comp1:=configOper_comp1.create ("comp1 alive") alive;
    var configOper_comp1 comp2:=configOper_comp1.create ("comp2 alive") alive;
    comp.start(configOper_behav0());
    comp1.start(configOper_behav0());
    comp2.start(configOper_behav0());
    if (all component.running) {setverdict(pass)}
    else {setverdict(fail)};

    xx1 := 0;
    do {
        alt {
            [] all component.killed {
                if (xx1==3) {setverdict(pass);}
            }
            [] comp.killed {
                all component.kill;
                if (xx1!=2) {setverdict(fail);}
            }
            [] any component.killed {
                comp.kill;
                if (xx1!=1) {setverdict(fail);}
            }
            [else] {
                comp1.kill;
                if (xx1!=0) {setverdict(fail);}
            }
        }
        xx1 := xx1 + 1;
    } while ( xx1!=4);
    if (any component.alive) {setverdict(fail)}
    else {setverdict(pass)};
};

testcase configOperConnectMtc_alive() runs on configOper_comp1 {
    var configOper_comp1 comp:=configOper_comp1.create alive;
    connect(mtc:Port1,comp:Port1);
    comp.start(configOper_behav4());
    xx1:=5;
    Port1.send(xx1);
    comp.done;

    comp.start(configOper_behav6());
    Port1.receive(integer:?) -> value xx1;
    if (xx1==8) {setverdict(pass)}
    else {setverdict(fail)};
    comp.stop;

    comp.start(configOper_behav5());
    comp.done;

    comp.start(configOper_behav6());
    Port1.receive(integer:?) -> value xx1;
    if (xx1==210) {setverdict(pass)}
    else {setverdict(fail)};
    comp.kill;
};

testcase configOperConnectSelf_alive() runs on configOper_comp1 {
    var configOper_comp1 comp:=configOper_comp1.create alive;
    connect(self:Port1,comp:Port1);
    comp.start(configOper_behav4());
    xx1:=5;
    Port1.send(xx1);
    comp.done;

    comp.start(configOper_behav6());
    Port1.receive(integer:?) -> value xx1;
    if (xx1==8) {setverdict(pass)}
    else {setverdict(fail)};
    comp.stop;

    comp.start(configOper_behav5());
    comp.done;

    comp.start(configOper_behav6());
    Port1.receive(integer:?) -> value xx1;
    if (xx1==210) {setverdict(pass)}
    else {setverdict(fail)};
    comp.kill;
};

testcase configOperDisconnect_alive() runs on configOper_comp1 {
    var configOper_comp1 comp1:=configOper_comp1.create alive;
    var configOper_comp1 comp2:=configOper_comp1.create alive;
    comp1.start(configOper_behav1());
    comp2.start(configOper_behav2());
    connect(self:Port1,comp1:Port1);
    connect(self:Port1,comp2:Port1);
    disconnect(self:Port1,comp1:Port1);
    xx1:=5;
    Port1.send(xx1);
    Port1.receive(integer:?) -> value xx1;
    if (xx1==7) {setverdict(pass)}
    else {setverdict(fail)};
    comp1.kill;
    comp2.kill;
};

testcase configOperArray_alive() runs on configOper_comp3 {
    var configOper_comp1 comp[5];
    var integer i;
    xx1:=5;
    for (i:=0; i<5; i:=i+1)
    {
        comp[i]:=configOper_comp1.create alive;
        connect(self:Port3[i],comp[i]:Port1);
        comp[i].start(configOper_behav4());
        Port3[i].send(xx1);
        comp[i].done;
//        while (comp[i].running) {};
        comp[i].start(configOper_behav5());
        comp[i].done;
        comp[i].start(configOper_behav6());
        Port3[i].receive(integer:?) -> value xx1;
        if (xx1==i*203+208) {setverdict(pass)}
        else {setverdict(fail)};
    }
    for (i:=5; i<5; i:=i+1) {comp[i].kill};
};

testcase configOperRunningAny_alive() runs on configOper_comp2 {
    var configOper_comp1 comp[5];
    var integer i;
    xx2:=5;
    for (i:=0; i<5; i:=i+1)
    {
        comp[i]:=configOper_comp1.create alive;
        comp[i].start(configOper_behav0());
    }
    for (i:=0; i<4; i:=i+1)
    {
        comp[i].stop;
        if (any component.running) {setverdict(pass)}
        else {setverdict(fail)};
    }
    comp[4].stop;
    if (any component.running) {setverdict(fail)}
    else {setverdict(pass)};
};

testcase configOperRunningAll_alive() runs on configOper_comp2 {
    var configOper_comp1 comp[5];
    var integer i;
    xx2:=5;
    for (i:=0; i<5; i:=i+1)
    {
        comp[i]:=configOper_comp1.create alive;
    }
    for (i:=0; i<5; i:=i+1)
    {
        comp[i].start(configOper_behav7(int2float(i + 1)));
    }
    if (all component.running) {setverdict(pass)}
    else {setverdict(fail)};

    comp[0].done;
    if (all component.running) {setverdict(fail)}
    else {setverdict(pass)};

    comp[0].start(configOper_behav7(1.0));
    for (i:=0; i<5; i:=i+1)
    {
        comp[i].stop;
        if (all component.running) {setverdict(pass)}
        else {setverdict(fail)};
    }
    for (i:=0; i<5; i:=i+1)
    {
        comp[i].kill;
        if (all component.running) {setverdict(pass)}
        else {setverdict(fail)};
    }
};

testcase configOperAliveAny_alive() runs on configOper_comp2 {
    var configOper_comp1 comp[5];
    var integer i;
    xx2:=5;
    for (i:=0; i<5; i:=i+1)
    {
        comp[i]:=configOper_comp1.create alive;
        comp[i].start(configOper_behav0());
    }
    for (i:=0; i<4; i:=i+1)
    {
        comp[i].kill;
        if (any component.alive) {setverdict(pass)}
        else {setverdict(fail)};
    }
    comp[4].kill;
    if (any component.alive) {setverdict(fail)}
    else {setverdict(pass)};
};

testcase configOperAliveAll_alive() runs on configOper_comp2 {
    var configOper_comp1 comp[5];
    var integer i;
    xx2:=5;
    for (i:=0; i<5; i:=i+1)
    {
        comp[i]:=configOper_comp1.create alive;
        comp[i].start(configOper_behav0());
    }
    if (all component.alive) {setverdict(pass)}
    else {setverdict(fail)};
    for (i:=0; i<5; i:=i+1)
    {
        comp[i].kill;
        if (all component.alive) {setverdict(fail)}
        else {setverdict(pass)};
    }
};

testcase configOperDone_alive() runs on configOper_comp1 {
    var configOper_comp1 comp:=configOper_comp1.create alive;
    timer T1:=10.0;
    connect(self:Port1,comp:Port1);
    comp.start(configOper_behav3());
    xx1:=5;
    Port1.send(xx1);
    T1.start;
    alt {
        [] Port1.receive(integer:?) -> value xx1 {setverdict(fail, "received a value")}
        [] comp.done {setverdict(pass)}
        [] T1.timeout {setverdict(fail, "configOperDone_alive timed out after", T1.read, " seconds")}
    }
};

testcase configOperDone2_alive() runs on configOper_comp1 {
    var configOper_comp1 comp:=configOper_comp1.create alive;
    timer T1:=10.0;
    comp.start(configOper_behav0());
    comp.stop;
    alt {
        [] comp.done {setverdict(pass)}
        [else] {setverdict(fail)}
    }
    comp.kill;
    alt {
        [] comp.done {setverdict(pass)}
        [else] {setverdict(fail)}
    }
};

testcase configOperDoneAny_alive() runs on configOper_comp2 {
    var configOper_comp1 comp[5];
    var integer i;
    timer T1:=2.0;
    xx2:=5;
    for (i:=0; i<5; i:=i+1)
    {
        comp[i]:=configOper_comp1.create alive;
        connect(self:Port2[i],comp[i]:Port1);
        comp[i].start(configOper_behav3());
     }
    for (i:=0; i<5; i:=i+1) {
        log(i);
        Port2[i].send(xx2);
        T1.stop;
        T1.start;
        alt {
            [] Port2[i].receive(integer:?) {setverdict(fail)}
            [] any component.done {setverdict(pass)}
            [] T1.timeout {setverdict(fail)}
            [] comp[i].done {setverdict(fail)}
        }
    }
};

testcase configOperDoneAny2_alive() runs on configOper_comp1 {
    var configOper_comp1 comp:=configOper_comp1.create alive;
    var configOper_comp1 comp1:=configOper_comp1.create alive;
    timer T1:=10.0;
    comp.start(configOper_behav0());
    comp1.start(configOper_behav0());
    alt {
        [] any component.done {setverdict(fail)}
        [else] {setverdict(pass)}
    }
    comp.stop;
    alt {
        [] all component.done {setverdict(fail)}
        [] any component.done {setverdict(pass)}
        [else] {setverdict(fail)}
    }
    comp.kill;
    alt {
        [] all component.done {setverdict(fail)}
        [] any component.done {setverdict(pass)}
        [else] {setverdict(fail)}
    }
    all component.kill;
    alt {
        [] any component.done {setverdict(pass)}
        [else] {setverdict(fail)}
    }
};

testcase configOperDoneAll_alive() runs on configOper_comp2 {
    var configOper_comp1 comp[5];
    var integer i;
    timer T1:=2.0;
    xx2:=5;
    log("xx");
    for (i:=0; i<5; i:=i+1)
    {
        log(i);
        comp[i]:=configOper_comp1.create alive;
        connect(self:Port2[i],comp[i]:Port1);
        comp[i].start(configOper_behav3());
    }
    for (i:=0; i<5; i:=i+1) {
        log(i);
        Port2[i].send(xx2);
    }
    T1.start;
    alt {
        [] Port2[2].receive(integer:?) {setverdict(fail)}
        [] all component.done {setverdict(pass)}
        [] T1.timeout {setverdict(fail)}
    }
};

testcase configOperDoneAll2_alive() runs on configOper_comp2 {
    var configOper_comp1 comp[5];
    var integer i;
    for (i:=0; i<5; i:=i+1)
    {
        comp[i]:=configOper_comp1.create alive;
        comp[i].start(configOper_behav0());
    }
    for (i:=0; i<4; i:=i+1) {
        comp[i].stop;
    }
    comp[4].kill;
    alt {
        [] all component.done {setverdict(pass)}
        [else] {setverdict(fail)}
    }
};

testcase configOperKilled_alive() runs on configOper_comp1 {
    var configOper_comp1 comp:=configOper_comp1.create alive;
    timer T1:=10.0;
    comp.start(configOper_behav3());
    comp.kill;
    alt {
        [] comp.killed {setverdict(pass)}
        [else] {setverdict(fail)}
    }
};

testcase configOperKilledAny_alive() runs on configOper_comp2 {
    var configOper_comp1 comp[5];
    var integer i;
    timer T1:=2.0;
    xx2:=5;
    for (i:=0; i<5; i:=i+1)
    {
        comp[i]:=configOper_comp1.create alive;
        connect(self:Port2[i],comp[i]:Port1);
        comp[i].start(configOper_behav3());
     }
    for (i:=0; i<4; i:=i+1) {
        comp[i].kill;
        alt {
            [] all component.done {setverdict(fail)}
            [] any component.killed {setverdict(pass)}
            [else] {setverdict(fail)}
        }
    }
    comp[i].kill;
};

testcase configOperKilledAll_alive() runs on configOper_comp2 {
    var integer i;
    var configOper_comp1 comp[5];

    for (i:=0; i<5; i:=i+1)
    {
        comp[i]:=configOper_comp1.create alive;
        connect(self:Port2[i],comp[i]:Port1);
        comp[i].start(configOper_behav3());
    }
    for (i:=0; i<4; i:=i+1) {
        comp[i].kill;
        alt {
            [] all component.done {setverdict(fail)}
            [] any component.killed {setverdict(pass)}
            [else] {setverdict(fail)}
        }
    }
    comp[i].kill;
    alt {
        [] all component.killed {setverdict(pass)}
        [else] {setverdict(fail)}
    }
};

testcase configOperStopAll_alive() runs on configOper_comp2 {
    var configOper_comp1 comp[5];
    var integer i;
    for (i:=0; i<5; i:=i+1)
    {
        comp[i]:=configOper_comp1.create alive;
        connect(self:Port2[i],comp[i]:Port1);
        comp[i].start(configOper_behav3());
        Port2[i].start;
    }
    all component.stop;
    if (any component.running) {setverdict(fail)}
    else {setverdict(pass)};
    all component.kill;
}

testcase configOperKillAll_alive() runs on configOper_comp2 {
    var configOper_comp1 comp[5];
    var integer i;
    for (i:=0; i<5; i:=i+1)
    {
        comp[i]:=configOper_comp1.create alive;
        connect(self:Port2[i],comp[i]:Port1);
        comp[i].start(configOper_behav3());
        Port2[i].start;
    }
    all component.kill;
    if (any component.alive) {setverdict(fail)}
    else {setverdict(pass)};
}

testcase configOperAutoStopAndKill_alive() runs on configOper_comp2 {
    var configOper_comp1 comp[5];
    var integer i;
    timer T1:=2.0;
    xx2:=5;
    for (i:=0; i<5; i:=i+1)
    {
        comp[i]:=configOper_comp1.create alive;
        connect(self:Port2[i],comp[i]:Port1);
        comp[i].start(configOper_behav1());
        Port2[i].send(xx2);
    }
    T1.start;
    T1.timeout;
    setverdict(pass);
};

testcase configOperAutoStopAndKill2_alive() runs on configOper_comp2 {
    var configOper_comp1 comp[5];
    var integer i;
    timer T1:=2.0;
    xx2:=5;
    for (i:=0; i<5; i:=i+1)
    {
        comp[i]:=configOper_comp1.create alive;
        connect(self:Port2[i],comp[i]:Port1);
        comp[i].start(configOper_behav1());
    }
    for (i:=0; i<5; i:=i+1)
    {
        Port2[i].send(xx2);
        Port2[i].receive(integer:?) -> value xx2;
        if (xx2==i+6) {setverdict(pass)}
        else {setverdict(fail)};
    }
};

///////////////////////////////////////////////////////////////////////
///////////////////// Interleave Statement ////////////////////////////
///////////////////////////////////////////////////////////////////////
signature MySig() exception (integer);
signature MySig1(inout float par) exception (integer);
type port interleave_port_M message { inout integer, float } with { extension "internal" };
type port interleave_port_P procedure { inout MySig, MySig1 } with { extension "internal" };
template MySig MySigTemplate := {}
template MySig1 MySigTemplate1 := {55.1}

type component interleave_comp {
    port interleave_port_M Port1;
    port interleave_port_P Port2;
    port interleave_port_P Port3;
    var integer xx1;
    var float xx2;
    timer T;
};

function interleave_behav1(float par) runs on interleave_comp {
    T.start(par);
    T.timeout;
};

function interleave_behav2(integer par1, float par2) runs on interleave_comp {
    T.start(par2);
    T.timeout;
    if (par1==0) { Port1.send(par2); }
    else { Port1.send(par1); }
};

function interleave_behav3(float par1) runs on interleave_comp {
    T.start(par1); T.timeout;
    Port3.call(MySigTemplate1,nowait);
    T.start(par1); T.timeout;
    Port3.call(MySigTemplate,nowait);
    var integer path := 0;
    interleave {
        [] Port3.getcall(MySigTemplate1) {
            Port3.reply(MySigTemplate);
            if (path==1) {setverdict(pass)}
            else {setverdict(fail)};
            path := path+1;
        }
        [] Port3.getcall(MySigTemplate) {
            Port3.reply(MySigTemplate1);
            if (path==0) {setverdict(pass)}
            else {setverdict(fail)};
            path := path+1;
        }
    }
    if (path==2) {setverdict(pass)}
    else {setverdict(fail)};
};

function interleave_behav4(float par1) runs on interleave_comp {
    T.start(par1); T.timeout;
    Port3.call(MySigTemplate1,nowait);
    T.start(par1); T.timeout;
    Port3.call(MySigTemplate,nowait);
    var integer path := 0;
    interleave {
        [] Port3.getcall(MySigTemplate1) {
            Port3.raise(MySig1,integer:15);
            //interleave_verdict(1);
            if (path==1) {setverdict(pass)}
            else {setverdict(fail)};
            path := path+1;
        }
        [] Port3.getcall(MySigTemplate) {
            Port3.raise(MySig,integer:5);
            //interleave_verdict(0);
            if (path==0) {setverdict(pass)}
            else {setverdict(fail)};
            path := path+1;
        }
    }
    if (path==2) {setverdict(pass)}
    else {setverdict(fail)};
};

function interleave_behav5() runs on configOper_comp5
{
  T.start;
  // interleave example identical to TTCN-3 Basic Course
  interleave {
  [] P.receive(1) { Q.receive(2); R.receive(3); log("1st branch ready") }
  [] Q.receive(4) { P.send(-4); R.receive(5); log("2nd branch ready") }
  [] R.receive(6) { P.receive(7); Q.send(-7); Q.receive(8); log("3rd branch ready") }
  [] T.timeout    { R.send(0); P.receive(9); log("timeout branch ready") }
  }
  setverdict(pass)
}

testcase InterleaveStatem1() runs on interleave_comp {
    var integer loop := 0;
    var interleave_comp comp :=interleave_comp.create ("comp alive") alive;
    var interleave_comp comp1:=interleave_comp.create ("comp1 alive") alive;
    var interleave_comp comp2:=interleave_comp.create ("comp2 alive") alive;
    comp.start(interleave_behav1(1.2));
    comp1.start(interleave_behav1(3.2));
    comp2.start(interleave_behav1(2.2));
    if (all component.running) {setverdict(pass)}
    else {setverdict(fail, "not all components running")};
    var integer counter := 0;
    do {
        T.start(4.1);
        interleave {
            [] any component.killed {
                comp.kill;
                if (loop==0 and counter==3) {setverdict(pass)}
                else if (loop==1 and counter==7) {setverdict(pass)}
                else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
                action("Any Killed:  ", counter);
                counter := counter+1;
            }
            [] T.timeout{
                if (loop==0 and counter==6) {
                    setverdict(pass);
                    comp1:=interleave_comp.create ("comp1 alive") alive;
                    comp1.start(interleave_behav1(2.2));
                }
                else if (loop==1 and counter==13) {setverdict(pass)}
                else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
                action("Timeout:  ", counter);
                counter := counter+1;
            }
            [] comp1.done {
                all component.done;
                if (loop==0 and counter==1) {setverdict(pass)}
                else if (loop==1 and counter==9) {setverdict(pass)}
                else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
                action("Done:  ", counter);
                counter := counter+1;
            }
            [] all component.done {
                comp1.kill;
                if (loop==0 and counter==2) {setverdict(pass)}
                else if (loop==1 and counter==10) {setverdict(pass)}
                else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
                action("All Done:  ", counter);
                counter := counter+1;
            }
            [] all component.killed {
                if (loop==0 and counter==5) {setverdict(pass)}
                else if (loop==1 and counter==11) {setverdict(pass)}
                else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
                action("All Killed:  ", counter);
                counter := counter+1;
            }
            [] comp.killed {
                all component.kill;
                if (loop==0 and counter==4) {setverdict(pass)}
                else if (loop==1 and counter==8) {setverdict(pass)}
                else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
                action("Killed:  ", counter);
                counter := counter+1;
            }
            [] any component.done {
                if (loop==0 and counter==0) {setverdict(pass)}
                else if (loop==1 and counter==12) {setverdict(pass)}
                else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
                action("Any Done:  ", counter);
                counter := counter+1;
            }
        }
        loop := loop+1;
    } while (loop < 2);
    if (counter==14) {setverdict(pass)}
    else {setverdict(fail, "counter is: ", counter)};
};

testcase InterleaveStatem2() runs on interleave_comp {
    var interleave_comp comp :=interleave_comp.create ("comp alive") alive;
    var interleave_comp comp1:=interleave_comp.create ("comp1 alive") alive;
    connect(mtc:Port1,comp:Port1);
    connect(mtc:Port1,comp1:Port1);
    comp.start(interleave_behav2(34, 0.1));
    comp1.start(interleave_behav2(0, 0.1));
    T.start(0.1);
    interleave {
        [] Port1.receive (integer:?) -> value xx1 {
            log("Receive");
        }
        [] Port1.trigger (float:?) -> value xx2 {
            log("Trigger");
        }
        [] any port.trigger {
            log("Any Port Trigger");
        }
        [] T.timeout{
            log("Timeout");
            comp.done;
            comp1.done;
            comp.start(interleave_behav2(0, 0.1));
            comp1.start(interleave_behav2(50, 0.1));
        }
        [] any port.receive {
            log("Any Port Receive");
        }
  }
  setverdict(pass);
};

testcase InterleaveStatem3() runs on interleave_comp {
    var interleave_comp comp :=interleave_comp.create ("comp alive") alive;
    var interleave_comp comp1:=interleave_comp.create ("comp1 alive") alive;
    connect(self:Port2,comp:Port3);
    comp.start(interleave_behav3(0.1));
    T.start(0.1);
    var integer path1 := 0;// The execution path of comp1
    var integer path2 := 0;// the execution path of comp
    interleave {
        [] Port2.getcall(MySigTemplate1) {
            if (path2==0) {setverdict(pass)}
            else {setverdict(fail)};
            path2 := path2+1;
        }
        [] Port2.getreply(MySigTemplate1) {
            if (path2==2) {setverdict(pass)}
            else {setverdict(fail)};
            path2 := path2+1;
            Port2.call(MySigTemplate1,nowait);
        }
        [] comp1.done {
            if (path1==1) {setverdict(pass)}
            else {setverdict(fail)};
            path1 := path1+1;
        }
        [] T.timeout{
            if (path1==0) {setverdict(pass)}
            else {setverdict(fail)};
            path1 := path1+1;
            comp1.start(interleave_behav1(2.8));
        }
        [] any port.getcall {
            if (path2==1) {setverdict(pass)}
            else {setverdict(fail)};
            path2 := path2+1;
            Port2.call(MySigTemplate,nowait);
        }
        [] any port.getreply {
            if (path2==3) {setverdict(pass)}
            else {setverdict(fail)};
            path2 := path2+1;
        }
    }
    if (path1==2 and path2 == 4) {setverdict(pass)}
    else {setverdict(fail)};
};

testcase InterleaveStatem4() runs on interleave_comp {
    var interleave_comp comp :=interleave_comp.create ("comp alive") alive;
    connect(self:Port2,comp:Port3);
    comp.start(interleave_behav4(0.1));
    T.start(0.1);
    var integer path1 := 0;//The timeout executionpath
    var integer path2 := 0;//The real executionpath
    interleave {
        [] Port2.catch(MySig, integer:5) {
            Port2.call(MySigTemplate1,nowait);
            if (path2==2) {setverdict(pass)}
            else {setverdict(fail)};
            path2 := path2+1;
        }
        []Port2.check(getcall(MySigTemplate1)) {
            Port2.getcall;
            if (path2==0) {setverdict(pass)}
            else {setverdict(fail)};
            path2 := path2+1;
        }
        [] T.timeout{
            path1 := 1;
        }
        [] any port.check {
            any port.getcall;
            Port2.call(MySigTemplate,nowait);
            if (path2==1) {setverdict(pass)}
            else {setverdict(fail)};
            path2 := path2+1;
        }
        [] any port.catch {
            if (path2==3) {setverdict(pass)}
            else {setverdict(fail)};
            path2 := path2+1;
        }
    }
    if (path1==1 and path2==4) {setverdict(pass)}
    else {setverdict(fail)};
};

testcase InterleaveStatem5() runs on configOper_comp5
{
  var configOper_comp5 ptc := configOper_comp5.create;
  connect(mtc:P, ptc:P);
  connect(mtc:Q, ptc:Q);
  connect(mtc:R, ptc:R);
  ptc.start(interleave_behav5())

  // exercise interleave statement
  P.send(1); // start 1st branch
  Q.send(4); // start 2nd branch
  R.send(6); // start 3rd branch
  P.send(7); // continue 3rd branch
  Q.send(2); // switch back and continue with 1st branch
  R.send(5); // switch over, continue with 2nd branch, terminate 2nd branch
  T.start;   // enforce timeout event
  T.timeout; // begin with 4th branch
  Q.send(8); // switch over to 3rd branch, terminate 3rd branch
  P.send(9); // switch over and terminate to timeout branch 
  R.send(3); // switch over and terminate 1st branch
  // all branches are fully terminated, interleve should finish

  // wait for ptc to terminate normally
  T.start; 
  T.stop;

  // check if f_interleave() terminated properly
  T.start;
  alt {
  [] ptc.done  { T.stop; setverdict(pass) }
  [] T.timeout { ptc.kill; setverdict(fail) } // verdict is fail for hanging ptc
  }
}

testcase configOperConnectDisconnect() runs on configOper_comp1 {
var configOper_comp1 comp:=configOper_comp1.create;
connect(mtc:Port1,comp:Port1);
disconnect(mtc:Port1,comp:Port1);
connect(comp:Port1, mtc:Port1);
disconnect(mtc:Port1,comp:Port1);
connect(mtc:Port1,comp:Port1);
disconnect(comp:Port1, mtc:Port1);
connect(comp:Port1, mtc:Port1);
disconnect(comp:Port1, mtc:Port1);
comp.stop;
setverdict(pass);
};

testcase configOperMapUnmap() runs on configOper_comp4
  system configOper_comp4 {
var configOper_comp4 comp:=configOper_comp4.create;
map(mtc:Port4,system:Port4);
unmap(mtc:Port4,system:Port4);
map(system:Port4, mtc:Port4);
unmap(mtc:Port4,system:Port4);
map(mtc:Port4,system:Port4);
unmap(system:Port4, mtc:Port4);
map(system:Port4, mtc:Port4);
unmap(system:Port4, mtc:Port4);

map(comp:Port4,system:Port4);
unmap(comp:Port4,system:Port4);
map(system:Port4, comp:Port4);
unmap(comp:Port4,system:Port4);
map(comp:Port4,system:Port4);
unmap(system:Port4, comp:Port4);
map(system:Port4, comp:Port4);
unmap(system:Port4, comp:Port4);
comp.stop;
setverdict(pass);
};

control {
    execute(configOperRunning1());
    execute(configOperRunning2());
    execute(configOperConnectMtc());
    execute(configOperConnectSelf());
    execute(configOperDisconnect());
    execute(configOperDone());
    execute(configOperArray());
    execute(configOperRunningAny());
    execute(configOperRunningAll());
    execute(configOperDoneAny());
    execute(configOperDoneAny2());
    execute(configOperDoneAny3());
    execute(configOperDoneAll());
    execute(configOperStopAll());
    execute(configOperAutostop1());
    execute(configOperAutostop2());

    execute(configOperRunningAlive_alive());
    execute(configOperRunningAliveKill_alive());
    execute(configOperRunningAliveKillMixed_alive());
    execute(configOperRunningAliveKillKilledMixed_alive());
    execute(configOperConnectMtc_alive());
    execute(configOperConnectSelf_alive());
    execute(configOperDisconnect_alive());
    execute(configOperArray_alive());
    execute(configOperRunningAny_alive());
    execute(configOperRunningAll_alive());
    execute(configOperAliveAny_alive());
    execute(configOperAliveAll_alive());
    execute(configOperDone_alive());
    execute(configOperDone2_alive());
    execute(configOperDoneAny_alive());
    execute(configOperDoneAny2_alive());
    execute(configOperDoneAll_alive());
    execute(configOperDoneAll2_alive());
    execute(configOperKilled_alive());
    execute(configOperKilledAny_alive());
    execute(configOperKilledAll_alive());
    execute(configOperStopAll_alive());
    execute(configOperKillAll_alive());
    execute(configOperAutoStopAndKill_alive());
    execute(configOperAutoStopAndKill2_alive());

    execute(InterleaveStatem1());
    execute(InterleaveStatem2());
    execute(InterleaveStatem3());
    execute(InterleaveStatem4());
    execute(InterleaveStatem5());
    execute(configOperConnectDisconnect());
    execute(configOperMapUnmap());
}
}