regression_test/configOper/TconfigOper.ttcn

   1 /******************************************************************************
   2  * Copyright (c) 2000-2014 Ericsson Telecom AB
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  ******************************************************************************/
   8 module TconfigOper {
   9
  10 type port configOper_port1 message
  11 { inout integer } with { extension "internal" };
  12
  13 // A "black hole" port.
  14 type port configOper_port2 message {
  15  inout charstring;
  16  }
  17
  18 type component configOper_comp1 {
  19  port configOper_port1 Port1;
  20  var integer xx1;
  21  };
  22
  23 type component configOper_comp2 {
  24  port configOper_port1 Port2[5];
  25  var integer xx2;
  26  };
  27
  28 type component configOper_comp4 {
  29  port configOper_port2 Port4;
  30  }
  31
  32 type component configOper_comp5 {
  33   port configOper_port1 P, Q, R;
  34   timer T := 1.0;
  35 }
  36
  37 function configOper_behav0() runs on configOper_comp1 {
  38 timer T:=1.0; // doing nothing, alt is needed for "stop"
  39 while (true) {
  40   T.start;
  41   alt
  42    { [] T.timeout {T.start}   }
  43   };
  44 };
  45
  46 function configOper_behav1() runs on configOper_comp1 {
  47                 //sends back x+1
  48 Port1.receive(integer:?) -> value xx1;
  49 xx1:=xx1+1;
  50 Port1.send(xx1);
  51 };
  52
  53 function configOper_behav2() runs on configOper_comp1 {
  54                 //sends back x+2
  55 Port1.receive(integer:?) -> value xx1;
  56 xx1:=xx1+2;
  57 Port1.send(xx1);
  58 };
  59
  60 function configOper_behav3() runs on configOper_comp1 {
  61 timer TT:=1.0;
  62                 //if receives anything -> stops
  63 Port1.receive(integer:?);
  64 TT.start;
  65 alt
  66  { [] Port1.receive(integer:?) { action("configOper_behav3 received the integer after ", TT.read, " seconds");};
  67    [] TT.timeout { action("configOper_behav3 timed out"); stop; } };
  68 };
  69
  70 testcase configOperRunning1() runs on configOper_comp1 {
  71 var configOper_comp1 comp:=configOper_comp1.create;
  72 comp.start(configOper_behav0());
  73 if (comp.running) {setverdict(pass)}
  74   else {setverdict(fail)};
  75 comp.stop;
  76 };
  77
  78 testcase configOperRunning2() runs on configOper_comp1 {
  79 var configOper_comp1 comp:=configOper_comp1.create;
  80 comp.start(configOper_behav0());
  81 comp.stop;
  82 if (comp.running) {setverdict(fail)}
  83   else {setverdict(pass)};
  84 };
  85
  86 testcase configOperConnectMtc() runs on configOper_comp1 {
  87 var configOper_comp1 comp:=configOper_comp1.create;
  88 connect(mtc:Port1,comp:Port1);
  89 comp.start(configOper_behav1());
  90 xx1:=5;
  91 Port1.send(xx1);
  92 Port1.receive(integer:?) -> value xx1;
  93 if (xx1==6) {setverdict(pass)}
  94   else {setverdict(fail)};
  95 comp.stop;
  96 };
  97
  98 testcase configOperConnectSelf() runs on configOper_comp1 {
  99 var configOper_comp1 comp:=configOper_comp1.create;
 100 connect(self:Port1,comp:Port1);
 101 comp.start(configOper_behav1());
 102 xx1:=5;
 103 Port1.send(xx1);
 104 Port1.receive(integer:?) -> value xx1;
 105 if (xx1==6) {setverdict(pass)}
 106   else {setverdict(fail)};
 107 comp.stop;
 108 };
 109
 110 testcase configOperDisconnect() runs on configOper_comp1 {
 111 var configOper_comp1 comp1:=configOper_comp1.create;
 112 var configOper_comp1 comp2:=configOper_comp1.create;
 113 comp1.start(configOper_behav1());
 114 comp2.start(configOper_behav2());
 115 connect(self:Port1,comp1:Port1);
 116 disconnect(self:Port1,comp1:Port1);
 117 connect(self:Port1,comp2:Port1);
 118 xx1:=5;
 119 Port1.send(xx1);
 120 Port1.receive(integer:?) -> value xx1;
 121 if (xx1==7) {setverdict(pass)}
 122   else {setverdict(fail)};
 123 comp1.stop;
 124 comp2.stop;
 125 };
 126
 127 testcase configOperDone() runs on configOper_comp1 {
 128 var configOper_comp1 comp:=configOper_comp1.create;
 129 timer T1:=10.0;
 130 connect(self:Port1,comp:Port1);
 131 comp.start(configOper_behav3());
 132 xx1:=5;
 133 Port1.send(xx1);
 134 T1.start;
 135 alt {
 136  [] Port1.receive(integer:?) -> value xx1 {setverdict(fail)}
 137  [] comp.done {setverdict(pass)}
 138  [] T1.timeout {setverdict(fail)}
 139 }
 140 };
 141
 142 testcase configOperArray() runs on configOper_comp2 {
 143 var configOper_comp1 comp[5];
 144 var integer i;
 145 xx2:=5;
 146 for (i:=0; i<5; i:=i+1)
 147 { comp[i]:=configOper_comp1.create;
 148   connect(self:Port2[i],comp[i]:Port1);
 149   comp[i].start(configOper_behav1());
 150   Port2[i].send(xx2);
 151   Port2[i].receive(integer:?) -> value xx2;
 152   if (xx2==i+6) {setverdict(pass)}
 153     else {setverdict(fail)};
 154 }
 155 for (i:=5; i<5; i:=i+1) {comp[i].stop};
 156 };
 157
 158 testcase configOperRunningAny() runs on configOper_comp2 {
 159 var configOper_comp1 comp[5];
 160 var integer i;
 161 xx2:=5;
 162 for (i:=0; i<5; i:=i+1)
 163 { comp[i]:=configOper_comp1.create;
 164   comp[i].start(configOper_behav0());
 165 }
 166 for (i:=0; i<4; i:=i+1)
 167 { comp[i].stop;
 168   if (any component.running) {setverdict(pass)}
 169     else {setverdict(fail)};
 170 }
 171 comp[4].stop;
 172 if (any component.running) {setverdict(fail)}
 173   else {setverdict(pass)};
 174 };
 175
 176 testcase configOperRunningAll() runs on configOper_comp2 {
 177 var configOper_comp1 comp[5];
 178 var integer i;
 179 xx2:=5;
 180 for (i:=0; i<5; i:=i+1)
 181 { comp[i]:=configOper_comp1.create;
 182   comp[i].start(configOper_behav0());
 183 }
 184 if (all component.running) {setverdict(pass)}
 185   else {setverdict(fail)};
 186 for (i:=0; i<5; i:=i+1)
 187 { comp[i].stop;
 188   if (all component.running) {setverdict(pass)}
 189     else {setverdict(fail)};
 190 }
 191 };
 192
 193 testcase configOperDoneAny() runs on configOper_comp2 {
 194   var configOper_comp1 comp[5];
 195   var integer i;
 196   timer T1:=2.0;
 197   xx2:=5;
 198   for (i:=0; i<5; i:=i+1)
 199   { comp[i]:=configOper_comp1.create;
 200     connect(self:Port2[i],comp[i]:Port1);
 201     comp[i].start(configOper_behav3());
 202   }
 203   for (i:=0; i<5; i:=i+1) {
 204     Port2[i].send(xx2);
 205   }
 206
 207   T1.start;
 208   T1.stop;
 209
 210     alt {
 211       [] any component.done {setverdict(pass)}
 212       [] T1.timeout {setverdict(fail)}
 213     }
 214
 215 };
 216
 217 testcase configOperDoneAny2() runs on configOper_comp2 {
 218   var configOper_comp1 ptc;
 219   timer T1 := 1.0;
 220   T1.start;
 221   alt {
 222   [] any component.done { setverdict(fail); }
 223   [] T1.timeout { setverdict(pass); }
 224   }
 225   ptc := configOper_comp1.create;
 226   T1.start;
 227   alt {
 228   [] any component.done { setverdict(fail); }
 229   [] T1.timeout { setverdict(pass); }
 230   }
 231   ptc.stop;
 232   T1.start;
 233   alt {
 234   [] any component.done { setverdict(pass); }
 235   [] T1.timeout { setverdict(fail); }
 236   }
 237 }
 238
 239 testcase configOperDoneAny3() runs on configOper_comp2 {
 240   var configOper_comp1 ptc := configOper_comp1.create;
 241   timer T1 := 1.0;
 242   ptc.kill;
 243   T1.start;
 244   alt {
 245   [] any component.done { setverdict(pass); }
 246   [] T1.timeout { setverdict(fail); }
 247   }
 248 }
 249
 250 testcase configOperDoneAll() runs on configOper_comp2 {
 251 var configOper_comp1 comp[5];
 252 var integer i;
 253 timer T1:=2.0;
 254 xx2:=5;
 255 log("xx");
 256 for (i:=0; i<5; i:=i+1)
 257 { log(i);
 258   comp[i]:=configOper_comp1.create;
 259   connect(self:Port2[i],comp[i]:Port1);
 260   comp[i].start(configOper_behav3());
 261  }
 262 for (i:=0; i<5; i:=i+1) {
 263   log(i);
 264   Port2[i].send(xx2);
 265  }
 266 T1.start;
 267   alt {
 268     [] Port2[2].receive(integer:?) {setverdict(fail)}
 269     [] all component.done {setverdict(pass)}
 270     [] T1.timeout {setverdict(fail)}
 271        }
 272 };
 273
 274 testcase configOperStopAll() runs on configOper_comp2 {
 275 var configOper_comp1 comp[5];
 276 var integer i;
 277 //timer T1:=2.0;
 278 //xx2:=5;
 279 for (i:=0; i<5; i:=i+1)
 280 { log(i);
 281   comp[i]:=configOper_comp1.create;
 282   log("z");
 283   connect(self:Port2[i],comp[i]:Port1);
 284   comp[i].start(configOper_behav3());
 285   Port2[i].start;
 286  }
 287 all component.stop;
 288 if (any component.running) {setverdict(fail)}
 289     else {setverdict(pass)};
 290 }
 291
 292 testcase configOperAutostop1() runs on configOper_comp2 {
 293 var configOper_comp1 comp[5];
 294 var integer i;
 295 timer T1:=2.0;
 296 xx2:=5;
 297 for (i:=0; i<5; i:=i+1)
 298 { comp[i]:=configOper_comp1.create;
 299   connect(self:Port2[i],comp[i]:Port1);
 300   comp[i].start(configOper_behav1());
 301   Port2[i].send(xx2);
 302  }
 303 all component.done;
 304 setverdict(pass);
 305 };
 306
 307 testcase configOperAutostop2() runs on configOper_comp2 {
 308 var configOper_comp1 comp[5];
 309 var integer i;
 310 timer T1:=2.0;
 311 xx2:=5;
 312 for (i:=0; i<5; i:=i+1)
 313 { comp[i]:=configOper_comp1.create;
 314   connect(self:Port2[i],comp[i]:Port1);
 315   comp[i].start(configOper_behav1());
 316  }
 317 for (i:=0; i<5; i:=i+1)
 318 { Port2[i].send(xx2);
 319   Port2[i].receive(integer:?) -> value xx2;
 320   if (xx2==i+6) {setverdict(pass)}
 321     else {setverdict(fail)};
 322 }
 323 for (i:=5; i<5; i:=i+1) {comp[i].done};
 324 };
 325
 326 type component configOper_comp3 {
 327     port configOper_port1 Port3[5];
 328     var integer xx1;
 329 };
 330
 331 function configOper_behav4() runs on configOper_comp1 {
 332     Port1.receive(integer:?) -> value xx1;
 333     xx1:=xx1+1;
 334 };
 335
 336 function configOper_behav5() runs on configOper_comp1 {
 337     xx1:=xx1+200;
 338 };
 339
 340 function configOper_behav6() runs on configOper_comp1 {
 341     xx1:=xx1+2;
 342     Port1.send(xx1);
 343 };
 344
 345 function configOper_behav7(float par) runs on configOper_comp1 {
 346     timer T:=par;
 347     T.start;
 348     T.timeout;
 349 };
 350
 351 testcase configOperRunningAlive_alive() runs on configOper_comp1 {
 352     var configOper_comp1 comp:=configOper_comp1.create alive;
 353     comp.start(configOper_behav0());
 354     if (comp.running and comp.alive)
 355         {setverdict(pass)}
 356     else
 357         {setverdict(fail)};
 358     comp.kill;
 359 };
 360
 361 testcase configOperRunningAliveKill_alive() runs on configOper_comp1 {
 362     var configOper_comp1 comp:=configOper_comp1.create alive;
 363     comp.start(configOper_behav0());
 364     comp.stop;
 365     if (comp.running) {setverdict(fail)}
 366     else {setverdict(pass)};
 367     if (comp.alive) {setverdict(pass)}
 368     else {setverdict(fail)};
 369
 370     comp.kill;
 371     if (comp.alive) {setverdict(fail)}
 372     else {setverdict(pass)};
 373 };
 374
 375 testcase configOperRunningAliveKillMixed_alive() runs on configOper_comp1 {
 376     var configOper_comp1 comp :=configOper_comp1.create alive;
 377     var configOper_comp1 comp1:=configOper_comp1.create alive;
 378     var configOper_comp1 comp2:=configOper_comp1.create alive;
 379     comp.start(configOper_behav0());
 380     comp1.start(configOper_behav0());
 381     comp2.start(configOper_behav0());
 382     if (all component.running) {setverdict(pass)}
 383     else {setverdict(fail)};
 384
 385     comp.stop;
 386     comp1.stop;
 387     comp2.stop;
 388     if (any component.running) {setverdict(fail)}
 389     else {setverdict(pass)};
 390     if (all component.alive) {setverdict(pass)}
 391     else {setverdict(fail)};
 392
 393     comp.kill;
 394     if (all component.alive) {setverdict(fail)}
 395     else {setverdict(pass)};
 396     if (any component.alive) {setverdict(pass)}
 397     else {setverdict(fail)};
 398
 399     all component.kill;
 400     if (any component.alive) {setverdict(fail)}
 401     else {setverdict(pass)};
 402 };
 403
 404 testcase configOperRunningAliveKillKilledMixed_alive() runs on configOper_comp1 {
 405     var configOper_comp1 comp :=configOper_comp1.create ("comp alive") alive;
 406     var configOper_comp1 comp1:=configOper_comp1.create ("comp1 alive") alive;
 407     var configOper_comp1 comp2:=configOper_comp1.create ("comp2 alive") alive;
 408     comp.start(configOper_behav0());
 409     comp1.start(configOper_behav0());
 410     comp2.start(configOper_behav0());
 411     if (all component.running) {setverdict(pass)}
 412     else {setverdict(fail)};
 413
 414     xx1 := 0;
 415     do {
 416         alt {
 417             [] all component.killed {
 418                 if (xx1==3) {setverdict(pass);}
 419             }
 420             [] comp.killed {
 421                 all component.kill;
 422                 if (xx1!=2) {setverdict(fail);}
 423             }
 424             [] any component.killed {
 425                 comp.kill;
 426                 if (xx1!=1) {setverdict(fail);}
 427             }
 428             [else] {
 429                 comp1.kill;
 430                 if (xx1!=0) {setverdict(fail);}
 431             }
 432         }
 433         xx1 := xx1 + 1;
 434     } while ( xx1!=4);
 435     if (any component.alive) {setverdict(fail)}
 436     else {setverdict(pass)};
 437 };
 438
 439 testcase configOperConnectMtc_alive() runs on configOper_comp1 {
 440     var configOper_comp1 comp:=configOper_comp1.create alive;
 441     connect(mtc:Port1,comp:Port1);
 442     comp.start(configOper_behav4());
 443     xx1:=5;
 444     Port1.send(xx1);
 445     comp.done;
 446
 447     comp.start(configOper_behav6());
 448     Port1.receive(integer:?) -> value xx1;
 449     if (xx1==8) {setverdict(pass)}
 450     else {setverdict(fail)};
 451     comp.stop;
 452
 453     comp.start(configOper_behav5());
 454     comp.done;
 455
 456     comp.start(configOper_behav6());
 457     Port1.receive(integer:?) -> value xx1;
 458     if (xx1==210) {setverdict(pass)}
 459     else {setverdict(fail)};
 460     comp.kill;
 461 };
 462
 463 testcase configOperConnectSelf_alive() runs on configOper_comp1 {
 464     var configOper_comp1 comp:=configOper_comp1.create alive;
 465     connect(self:Port1,comp:Port1);
 466     comp.start(configOper_behav4());
 467     xx1:=5;
 468     Port1.send(xx1);
 469     comp.done;
 470
 471     comp.start(configOper_behav6());
 472     Port1.receive(integer:?) -> value xx1;
 473     if (xx1==8) {setverdict(pass)}
 474     else {setverdict(fail)};
 475     comp.stop;
 476
 477     comp.start(configOper_behav5());
 478     comp.done;
 479
 480     comp.start(configOper_behav6());
 481     Port1.receive(integer:?) -> value xx1;
 482     if (xx1==210) {setverdict(pass)}
 483     else {setverdict(fail)};
 484     comp.kill;
 485 };
 486
 487 testcase configOperDisconnect_alive() runs on configOper_comp1 {
 488     var configOper_comp1 comp1:=configOper_comp1.create alive;
 489     var configOper_comp1 comp2:=configOper_comp1.create alive;
 490     comp1.start(configOper_behav1());
 491     comp2.start(configOper_behav2());
 492     connect(self:Port1,comp1:Port1);
 493     connect(self:Port1,comp2:Port1);
 494     disconnect(self:Port1,comp1:Port1);
 495     xx1:=5;
 496     Port1.send(xx1);
 497     Port1.receive(integer:?) -> value xx1;
 498     if (xx1==7) {setverdict(pass)}
 499     else {setverdict(fail)};
 500     comp1.kill;
 501     comp2.kill;
 502 };
 503
 504 testcase configOperArray_alive() runs on configOper_comp3 {
 505     var configOper_comp1 comp[5];
 506     var integer i;
 507     xx1:=5;
 508     for (i:=0; i<5; i:=i+1)
 509     {
 510         comp[i]:=configOper_comp1.create alive;
 511         connect(self:Port3[i],comp[i]:Port1);
 512         comp[i].start(configOper_behav4());
 513         Port3[i].send(xx1);
 514         comp[i].done;
 515 //        while (comp[i].running) {};
 516         comp[i].start(configOper_behav5());
 517         comp[i].done;
 518         comp[i].start(configOper_behav6());
 519         Port3[i].receive(integer:?) -> value xx1;
 520         if (xx1==i*203+208) {setverdict(pass)}
 521         else {setverdict(fail)};
 522     }
 523     for (i:=5; i<5; i:=i+1) {comp[i].kill};
 524 };
 525
 526 testcase configOperRunningAny_alive() runs on configOper_comp2 {
 527     var configOper_comp1 comp[5];
 528     var integer i;
 529     xx2:=5;
 530     for (i:=0; i<5; i:=i+1)
 531     {
 532         comp[i]:=configOper_comp1.create alive;
 533         comp[i].start(configOper_behav0());
 534     }
 535     for (i:=0; i<4; i:=i+1)
 536     {
 537         comp[i].stop;
 538         if (any component.running) {setverdict(pass)}
 539         else {setverdict(fail)};
 540     }
 541     comp[4].stop;
 542     if (any component.running) {setverdict(fail)}
 543     else {setverdict(pass)};
 544 };
 545
 546 testcase configOperRunningAll_alive() runs on configOper_comp2 {
 547     var configOper_comp1 comp[5];
 548     var integer i;
 549     xx2:=5;
 550     for (i:=0; i<5; i:=i+1)
 551     {
 552         comp[i]:=configOper_comp1.create alive;
 553     }
 554     for (i:=0; i<5; i:=i+1)
 555     {
 556         comp[i].start(configOper_behav7(int2float(i + 1)));
 557     }
 558     if (all component.running) {setverdict(pass)}
 559     else {setverdict(fail)};
 560
 561     comp[0].done;
 562     if (all component.running) {setverdict(fail)}
 563     else {setverdict(pass)};
 564
 565     comp[0].start(configOper_behav7(1.0));
 566     for (i:=0; i<5; i:=i+1)
 567     {
 568         comp[i].stop;
 569         if (all component.running) {setverdict(pass)}
 570         else {setverdict(fail)};
 571     }
 572     for (i:=0; i<5; i:=i+1)
 573     {
 574         comp[i].kill;
 575         if (all component.running) {setverdict(pass)}
 576         else {setverdict(fail)};
 577     }
 578 };
 579
 580 testcase configOperAliveAny_alive() runs on configOper_comp2 {
 581     var configOper_comp1 comp[5];
 582     var integer i;
 583     xx2:=5;
 584     for (i:=0; i<5; i:=i+1)
 585     {
 586         comp[i]:=configOper_comp1.create alive;
 587         comp[i].start(configOper_behav0());
 588     }
 589     for (i:=0; i<4; i:=i+1)
 590     {
 591         comp[i].kill;
 592         if (any component.alive) {setverdict(pass)}
 593         else {setverdict(fail)};
 594     }
 595     comp[4].kill;
 596     if (any component.alive) {setverdict(fail)}
 597     else {setverdict(pass)};
 598 };
 599
 600 testcase configOperAliveAll_alive() runs on configOper_comp2 {
 601     var configOper_comp1 comp[5];
 602     var integer i;
 603     xx2:=5;
 604     for (i:=0; i<5; i:=i+1)
 605     {
 606         comp[i]:=configOper_comp1.create alive;
 607         comp[i].start(configOper_behav0());
 608     }
 609     if (all component.alive) {setverdict(pass)}
 610     else {setverdict(fail)};
 611     for (i:=0; i<5; i:=i+1)
 612     {
 613         comp[i].kill;
 614         if (all component.alive) {setverdict(fail)}
 615         else {setverdict(pass)};
 616     }
 617 };
 618
 619 testcase configOperDone_alive() runs on configOper_comp1 {
 620     var configOper_comp1 comp:=configOper_comp1.create alive;
 621     timer T1:=10.0;
 622     connect(self:Port1,comp:Port1);
 623     comp.start(configOper_behav3());
 624     xx1:=5;
 625     Port1.send(xx1);
 626     T1.start;
 627     alt {
 628         [] Port1.receive(integer:?) -> value xx1 {setverdict(fail, "received a value")}
 629         [] comp.done {setverdict(pass)}
 630         [] T1.timeout {setverdict(fail, "configOperDone_alive timed out after", T1.read, " seconds")}
 631     }
 632 };
 633
 634 testcase configOperDone2_alive() runs on configOper_comp1 {
 635     var configOper_comp1 comp:=configOper_comp1.create alive;
 636     timer T1:=10.0;
 637     comp.start(configOper_behav0());
 638     comp.stop;
 639     alt {
 640         [] comp.done {setverdict(pass)}
 641         [else] {setverdict(fail)}
 642     }
 643     comp.kill;
 644     alt {
 645         [] comp.done {setverdict(pass)}
 646         [else] {setverdict(fail)}
 647     }
 648 };
 649
 650 testcase configOperDoneAny_alive() runs on configOper_comp2 {
 651     var configOper_comp1 comp[5];
 652     var integer i;
 653     timer T1:=2.0;
 654     xx2:=5;
 655     for (i:=0; i<5; i:=i+1)
 656     {
 657         comp[i]:=configOper_comp1.create alive;
 658         connect(self:Port2[i],comp[i]:Port1);
 659         comp[i].start(configOper_behav3());
 660      }
 661     for (i:=0; i<5; i:=i+1) {
 662         log(i);
 663         Port2[i].send(xx2);
 664         T1.stop;
 665         T1.start;
 666         alt {
 667             [] Port2[i].receive(integer:?) {setverdict(fail)}
 668             [] any component.done {setverdict(pass)}
 669             [] T1.timeout {setverdict(fail)}
 670             [] comp[i].done {setverdict(fail)}
 671         }
 672     }
 673 };
 674
 675 testcase configOperDoneAny2_alive() runs on configOper_comp1 {
 676     var configOper_comp1 comp:=configOper_comp1.create alive;
 677     var configOper_comp1 comp1:=configOper_comp1.create alive;
 678     timer T1:=10.0;
 679     comp.start(configOper_behav0());
 680     comp1.start(configOper_behav0());
 681     alt {
 682         [] any component.done {setverdict(fail)}
 683         [else] {setverdict(pass)}
 684     }
 685     comp.stop;
 686     alt {
 687         [] all component.done {setverdict(fail)}
 688         [] any component.done {setverdict(pass)}
 689         [else] {setverdict(fail)}
 690     }
 691     comp.kill;
 692     alt {
 693         [] all component.done {setverdict(fail)}
 694         [] any component.done {setverdict(pass)}
 695         [else] {setverdict(fail)}
 696     }
 697     all component.kill;
 698     alt {
 699         [] any component.done {setverdict(pass)}
 700         [else] {setverdict(fail)}
 701     }
 702 };
 703
 704 testcase configOperDoneAll_alive() runs on configOper_comp2 {
 705     var configOper_comp1 comp[5];
 706     var integer i;
 707     timer T1:=2.0;
 708     xx2:=5;
 709     log("xx");
 710     for (i:=0; i<5; i:=i+1)
 711     {
 712         log(i);
 713         comp[i]:=configOper_comp1.create alive;
 714         connect(self:Port2[i],comp[i]:Port1);
 715         comp[i].start(configOper_behav3());
 716     }
 717     for (i:=0; i<5; i:=i+1) {
 718         log(i);
 719         Port2[i].send(xx2);
 720     }
 721     T1.start;
 722     alt {
 723         [] Port2[2].receive(integer:?) {setverdict(fail)}
 724         [] all component.done {setverdict(pass)}
 725         [] T1.timeout {setverdict(fail)}
 726     }
 727 };
 728
 729 testcase configOperDoneAll2_alive() runs on configOper_comp2 {
 730     var configOper_comp1 comp[5];
 731     var integer i;
 732     for (i:=0; i<5; i:=i+1)
 733     {
 734         comp[i]:=configOper_comp1.create alive;
 735         comp[i].start(configOper_behav0());
 736     }
 737     for (i:=0; i<4; i:=i+1) {
 738         comp[i].stop;
 739     }
 740     comp[4].kill;
 741     alt {
 742         [] all component.done {setverdict(pass)}
 743         [else] {setverdict(fail)}
 744     }
 745 };
 746
 747 testcase configOperKilled_alive() runs on configOper_comp1 {
 748     var configOper_comp1 comp:=configOper_comp1.create alive;
 749     timer T1:=10.0;
 750     comp.start(configOper_behav3());
 751     comp.kill;
 752     alt {
 753         [] comp.killed {setverdict(pass)}
 754         [else] {setverdict(fail)}
 755     }
 756 };
 757
 758 testcase configOperKilledAny_alive() runs on configOper_comp2 {
 759     var configOper_comp1 comp[5];
 760     var integer i;
 761     timer T1:=2.0;
 762     xx2:=5;
 763     for (i:=0; i<5; i:=i+1)
 764     {
 765         comp[i]:=configOper_comp1.create alive;
 766         connect(self:Port2[i],comp[i]:Port1);
 767         comp[i].start(configOper_behav3());
 768      }
 769     for (i:=0; i<4; i:=i+1) {
 770         comp[i].kill;
 771         alt {
 772             [] all component.done {setverdict(fail)}
 773             [] any component.killed {setverdict(pass)}
 774             [else] {setverdict(fail)}
 775         }
 776     }
 777     comp[i].kill;
 778 };
 779
 780 testcase configOperKilledAll_alive() runs on configOper_comp2 {
 781     var integer i;
 782     var configOper_comp1 comp[5];
 783
 784     for (i:=0; i<5; i:=i+1)
 785     {
 786         comp[i]:=configOper_comp1.create alive;
 787         connect(self:Port2[i],comp[i]:Port1);
 788         comp[i].start(configOper_behav3());
 789     }
 790     for (i:=0; i<4; i:=i+1) {
 791         comp[i].kill;
 792         alt {
 793             [] all component.done {setverdict(fail)}
 794             [] any component.killed {setverdict(pass)}
 795             [else] {setverdict(fail)}
 796         }
 797     }
 798     comp[i].kill;
 799     alt {
 800         [] all component.killed {setverdict(pass)}
 801         [else] {setverdict(fail)}
 802     }
 803 };
 804
 805 testcase configOperStopAll_alive() runs on configOper_comp2 {
 806     var configOper_comp1 comp[5];
 807     var integer i;
 808     for (i:=0; i<5; i:=i+1)
 809     {
 810         comp[i]:=configOper_comp1.create alive;
 811         connect(self:Port2[i],comp[i]:Port1);
 812         comp[i].start(configOper_behav3());
 813         Port2[i].start;
 814     }
 815     all component.stop;
 816     if (any component.running) {setverdict(fail)}
 817     else {setverdict(pass)};
 818     all component.kill;
 819 }
 820
 821 testcase configOperKillAll_alive() runs on configOper_comp2 {
 822     var configOper_comp1 comp[5];
 823     var integer i;
 824     for (i:=0; i<5; i:=i+1)
 825     {
 826         comp[i]:=configOper_comp1.create alive;
 827         connect(self:Port2[i],comp[i]:Port1);
 828         comp[i].start(configOper_behav3());
 829         Port2[i].start;
 830     }
 831     all component.kill;
 832     if (any component.alive) {setverdict(fail)}
 833     else {setverdict(pass)};
 834 }
 835
 836 testcase configOperAutoStopAndKill_alive() runs on configOper_comp2 {
 837     var configOper_comp1 comp[5];
 838     var integer i;
 839     timer T1:=2.0;
 840     xx2:=5;
 841     for (i:=0; i<5; i:=i+1)
 842     {
 843         comp[i]:=configOper_comp1.create alive;
 844         connect(self:Port2[i],comp[i]:Port1);
 845         comp[i].start(configOper_behav1());
 846         Port2[i].send(xx2);
 847     }
 848     T1.start;
 849     T1.timeout;
 850     setverdict(pass);
 851 };
 852
 853 testcase configOperAutoStopAndKill2_alive() runs on configOper_comp2 {
 854     var configOper_comp1 comp[5];
 855     var integer i;
 856     timer T1:=2.0;
 857     xx2:=5;
 858     for (i:=0; i<5; i:=i+1)
 859     {
 860         comp[i]:=configOper_comp1.create alive;
 861         connect(self:Port2[i],comp[i]:Port1);
 862         comp[i].start(configOper_behav1());
 863     }
 864     for (i:=0; i<5; i:=i+1)
 865     {
 866         Port2[i].send(xx2);
 867         Port2[i].receive(integer:?) -> value xx2;
 868         if (xx2==i+6) {setverdict(pass)}
 869         else {setverdict(fail)};
 870     }
 871 };
 872
 873 ///////////////////////////////////////////////////////////////////////
 874 ///////////////////// Interleave Statement ////////////////////////////
 875 ///////////////////////////////////////////////////////////////////////
 876 signature MySig() exception (integer);
 877 signature MySig1(inout float par) exception (integer);
 878 type port interleave_port_M message { inout integer, float } with { extension "internal" };
 879 type port interleave_port_P procedure { inout MySig, MySig1 } with { extension "internal" };
 880 template MySig MySigTemplate := {}
 881 template MySig1 MySigTemplate1 := {55.1}
 882
 883 type component interleave_comp {
 884     port interleave_port_M Port1;
 885     port interleave_port_P Port2;
 886     port interleave_port_P Port3;
 887     var integer xx1;
 888     var float xx2;
 889     timer T;
 890 };
 891
 892 function interleave_behav1(float par) runs on interleave_comp {
 893     T.start(par);
 894     T.timeout;
 895 };
 896
 897 function interleave_behav2(integer par1, float par2) runs on interleave_comp {
 898     T.start(par2);
 899     T.timeout;
 900     if (par1==0) { Port1.send(par2); }
 901     else { Port1.send(par1); }
 902 };
 903
 904 function interleave_behav3(float par1) runs on interleave_comp {
 905     T.start(par1); T.timeout;
 906     Port3.call(MySigTemplate1,nowait);
 907     T.start(par1); T.timeout;
 908     Port3.call(MySigTemplate,nowait);
 909     var integer path := 0;
 910     interleave {
 911         [] Port3.getcall(MySigTemplate1) {
 912             Port3.reply(MySigTemplate);
 913             if (path==1) {setverdict(pass)}
 914             else {setverdict(fail)};
 915             path := path+1;
 916         }
 917         [] Port3.getcall(MySigTemplate) {
 918             Port3.reply(MySigTemplate1);
 919             if (path==0) {setverdict(pass)}
 920             else {setverdict(fail)};
 921             path := path+1;
 922         }
 923     }
 924     if (path==2) {setverdict(pass)}
 925     else {setverdict(fail)};
 926 };
 927
 928 function interleave_behav4(float par1) runs on interleave_comp {
 929     T.start(par1); T.timeout;
 930     Port3.call(MySigTemplate1,nowait);
 931     T.start(par1); T.timeout;
 932     Port3.call(MySigTemplate,nowait);
 933     var integer path := 0;
 934     interleave {
 935         [] Port3.getcall(MySigTemplate1) {
 936             Port3.raise(MySig1,integer:15);
 937             //interleave_verdict(1);
 938             if (path==1) {setverdict(pass)}
 939             else {setverdict(fail)};
 940             path := path+1;
 941         }
 942         [] Port3.getcall(MySigTemplate) {
 943             Port3.raise(MySig,integer:5);
 944             //interleave_verdict(0);
 945             if (path==0) {setverdict(pass)}
 946             else {setverdict(fail)};
 947             path := path+1;
 948         }
 949     }
 950     if (path==2) {setverdict(pass)}
 951     else {setverdict(fail)};
 952 };
 953
 954 function interleave_behav5() runs on configOper_comp5
 955 {
 956   T.start;
 957   // interleave example identical to TTCN-3 Basic Course
 958   interleave {
 959   [] P.receive(1) { Q.receive(2); R.receive(3); log("1st branch ready") }
 960   [] Q.receive(4) { P.send(-4); R.receive(5); log("2nd branch ready") }
 961   [] R.receive(6) { P.receive(7); Q.send(-7); Q.receive(8); log("3rd branch ready") }
 962   [] T.timeout    { R.send(0); P.receive(9); log("timeout branch ready") }
 963   }
 964   setverdict(pass)
 965 }
 966
 967 testcase InterleaveStatem1() runs on interleave_comp {
 968     var integer loop := 0;
 969     var interleave_comp comp :=interleave_comp.create ("comp alive") alive;
 970     var interleave_comp comp1:=interleave_comp.create ("comp1 alive") alive;
 971     var interleave_comp comp2:=interleave_comp.create ("comp2 alive") alive;
 972     comp.start(interleave_behav1(1.2));
 973     comp1.start(interleave_behav1(3.2));
 974     comp2.start(interleave_behav1(2.2));
 975     if (all component.running) {setverdict(pass)}
 976     else {setverdict(fail, "not all components running")};
 977     var integer counter := 0;
 978     do {
 979         T.start(4.1);
 980         interleave {
 981             [] any component.killed {
 982                 comp.kill;
 983                 if (loop==0 and counter==3) {setverdict(pass)}
 984                 else if (loop==1 and counter==7) {setverdict(pass)}
 985                 else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
 986                 action("Any Killed:  ", counter);
 987                 counter := counter+1;
 988             }
 989             [] T.timeout{
 990                 if (loop==0 and counter==6) {
 991                     setverdict(pass);
 992                     comp1:=interleave_comp.create ("comp1 alive") alive;
 993                     comp1.start(interleave_behav1(2.2));
 994                 }
 995                 else if (loop==1 and counter==13) {setverdict(pass)}
 996                 else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
 997                 action("Timeout:  ", counter);
 998                 counter := counter+1;
 999             }
1000             [] comp1.done {
1001                 all component.done;
1002                 if (loop==0 and counter==1) {setverdict(pass)}
1003                 else if (loop==1 and counter==9) {setverdict(pass)}
1004                 else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
1005                 action("Done:  ", counter);
1006                 counter := counter+1;
1007             }
1008             [] all component.done {
1009                 comp1.kill;
1010                 if (loop==0 and counter==2) {setverdict(pass)}
1011                 else if (loop==1 and counter==10) {setverdict(pass)}
1012                 else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
1013                 action("All Done:  ", counter);
1014                 counter := counter+1;
1015             }
1016             [] all component.killed {
1017                 if (loop==0 and counter==5) {setverdict(pass)}
1018                 else if (loop==1 and counter==11) {setverdict(pass)}
1019                 else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
1020                 action("All Killed:  ", counter);
1021                 counter := counter+1;
1022             }
1023             [] comp.killed {
1024                 all component.kill;
1025                 if (loop==0 and counter==4) {setverdict(pass)}
1026                 else if (loop==1 and counter==8) {setverdict(pass)}
1027                 else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
1028                 action("Killed:  ", counter);
1029                 counter := counter+1;
1030             }
1031             [] any component.done {
1032                 if (loop==0 and counter==0) {setverdict(pass)}
1033                 else if (loop==1 and counter==12) {setverdict(pass)}
1034                 else {setverdict(fail, "reached line" & int2str(__LINE__) & " loop: " & int2str(loop) & " counter: " & int2str(counter))};
1035                 action("Any Done:  ", counter);
1036                 counter := counter+1;
1037             }
1038         }
1039         loop := loop+1;
1040     } while (loop < 2);
1041     if (counter==14) {setverdict(pass)}
1042     else {setverdict(fail, "counter is: ", counter)};
1043 };
1044
1045 testcase InterleaveStatem2() runs on interleave_comp {
1046     var interleave_comp comp :=interleave_comp.create ("comp alive") alive;
1047     var interleave_comp comp1:=interleave_comp.create ("comp1 alive") alive;
1048     connect(mtc:Port1,comp:Port1);
1049     connect(mtc:Port1,comp1:Port1);
1050     comp.start(interleave_behav2(34, 0.1));
1051     comp1.start(interleave_behav2(0, 0.1));
1052     T.start(0.1);
1053     interleave {
1054         [] Port1.receive (integer:?) -> value xx1 {
1055             log("Receive");
1056         }
1057         [] Port1.trigger (float:?) -> value xx2 {
1058             log("Trigger");
1059         }
1060         [] any port.trigger {
1061             log("Any Port Trigger");
1062         }
1063         [] T.timeout{
1064             log("Timeout");
1065             comp.done;
1066             comp1.done;
1067             comp.start(interleave_behav2(0, 0.1));
1068             comp1.start(interleave_behav2(50, 0.1));
1069         }
1070         [] any port.receive {
1071             log("Any Port Receive");
1072         }
1073   }
1074   setverdict(pass);
1075 };
1076
1077 testcase InterleaveStatem3() runs on interleave_comp {
1078     var interleave_comp comp :=interleave_comp.create ("comp alive") alive;
1079     var interleave_comp comp1:=interleave_comp.create ("comp1 alive") alive;
1080     connect(self:Port2,comp:Port3);
1081     comp.start(interleave_behav3(0.1));
1082     T.start(0.1);
1083     var integer path1 := 0;// The execution path of comp1
1084     var integer path2 := 0;// the execution path of comp
1085     interleave {
1086         [] Port2.getcall(MySigTemplate1) {
1087             if (path2==0) {setverdict(pass)}
1088             else {setverdict(fail)};
1089             path2 := path2+1;
1090         }
1091         [] Port2.getreply(MySigTemplate1) {
1092             if (path2==2) {setverdict(pass)}
1093             else {setverdict(fail)};
1094             path2 := path2+1;
1095             Port2.call(MySigTemplate1,nowait);
1096         }
1097         [] comp1.done {
1098             if (path1==1) {setverdict(pass)}
1099             else {setverdict(fail)};
1100             path1 := path1+1;
1101         }
1102         [] T.timeout{
1103             if (path1==0) {setverdict(pass)}
1104             else {setverdict(fail)};
1105             path1 := path1+1;
1106             comp1.start(interleave_behav1(2.8));
1107         }
1108         [] any port.getcall {
1109             if (path2==1) {setverdict(pass)}
1110             else {setverdict(fail)};
1111             path2 := path2+1;
1112             Port2.call(MySigTemplate,nowait);
1113         }
1114         [] any port.getreply {
1115             if (path2==3) {setverdict(pass)}
1116             else {setverdict(fail)};
1117             path2 := path2+1;
1118         }
1119     }
1120     if (path1==2 and path2 == 4) {setverdict(pass)}
1121     else {setverdict(fail)};
1122 };
1123
1124 testcase InterleaveStatem4() runs on interleave_comp {
1125     var interleave_comp comp :=interleave_comp.create ("comp alive") alive;
1126     connect(self:Port2,comp:Port3);
1127     comp.start(interleave_behav4(0.1));
1128     T.start(0.1);
1129     var integer path1 := 0;//The timeout executionpath
1130     var integer path2 := 0;//The real executionpath
1131     interleave {
1132         [] Port2.catch(MySig, integer:5) {
1133             Port2.call(MySigTemplate1,nowait);
1134             if (path2==2) {setverdict(pass)}
1135             else {setverdict(fail)};
1136             path2 := path2+1;
1137         }
1138         []Port2.check(getcall(MySigTemplate1)) {
1139             Port2.getcall;
1140             if (path2==0) {setverdict(pass)}
1141             else {setverdict(fail)};
1142             path2 := path2+1;
1143         }
1144         [] T.timeout{
1145             path1 := 1;
1146         }
1147         [] any port.check {
1148             any port.getcall;
1149             Port2.call(MySigTemplate,nowait);
1150             if (path2==1) {setverdict(pass)}
1151             else {setverdict(fail)};
1152             path2 := path2+1;
1153         }
1154         [] any port.catch {
1155             if (path2==3) {setverdict(pass)}
1156             else {setverdict(fail)};
1157             path2 := path2+1;
1158         }
1159     }
1160     if (path1==1 and path2==4) {setverdict(pass)}
1161     else {setverdict(fail)};
1162 };
1163
1164 testcase InterleaveStatem5() runs on configOper_comp5
1165 {
1166   var configOper_comp5 ptc := configOper_comp5.create;
1167   connect(mtc:P, ptc:P);
1168   connect(mtc:Q, ptc:Q);
1169   connect(mtc:R, ptc:R);
1170   ptc.start(interleave_behav5())
1171
1172   // exercise interleave statement
1173   P.send(1); // start 1st branch
1174   Q.send(4); // start 2nd branch
1175   R.send(6); // start 3rd branch
1176   P.send(7); // continue 3rd branch
1177   Q.send(2); // switch back and continue with 1st branch
1178   R.send(5); // switch over, continue with 2nd branch, terminate 2nd branch
1179   T.start;   // enforce timeout event
1180   T.timeout; // begin with 4th branch
1181   Q.send(8); // switch over to 3rd branch, terminate 3rd branch
1182   P.send(9); // switch over and terminate to timeout branch
1183   R.send(3); // switch over and terminate 1st branch
1184   // all branches are fully terminated, interleve should finish
1185
1186   // wait for ptc to terminate normally
1187   T.start;
1188   T.stop;
1189
1190   // check if f_interleave() terminated properly
1191   T.start;
1192   alt {
1193   [] ptc.done  { T.stop; setverdict(pass) }
1194   [] T.timeout { ptc.kill; setverdict(fail) } // verdict is fail for hanging ptc
1195   }
1196 }
1197
1198 testcase configOperConnectDisconnect() runs on configOper_comp1 {
1199 var configOper_comp1 comp:=configOper_comp1.create;
1200 connect(mtc:Port1,comp:Port1);
1201 disconnect(mtc:Port1,comp:Port1);
1202 connect(comp:Port1, mtc:Port1);
1203 disconnect(mtc:Port1,comp:Port1);
1204 connect(mtc:Port1,comp:Port1);
1205 disconnect(comp:Port1, mtc:Port1);
1206 connect(comp:Port1, mtc:Port1);
1207 disconnect(comp:Port1, mtc:Port1);
1208 comp.stop;
1209 setverdict(pass);
1210 };
1211
1212 testcase configOperMapUnmap() runs on configOper_comp4
1213   system configOper_comp4 {
1214 var configOper_comp4 comp:=configOper_comp4.create;
1215 map(mtc:Port4,system:Port4);
1216 unmap(mtc:Port4,system:Port4);
1217 map(system:Port4, mtc:Port4);
1218 unmap(mtc:Port4,system:Port4);
1219 map(mtc:Port4,system:Port4);
1220 unmap(system:Port4, mtc:Port4);
1221 map(system:Port4, mtc:Port4);
1222 unmap(system:Port4, mtc:Port4);
1223
1224 map(comp:Port4,system:Port4);
1225 unmap(comp:Port4,system:Port4);
1226 map(system:Port4, comp:Port4);
1227 unmap(comp:Port4,system:Port4);
1228 map(comp:Port4,system:Port4);
1229 unmap(system:Port4, comp:Port4);
1230 map(system:Port4, comp:Port4);
1231 unmap(system:Port4, comp:Port4);
1232 comp.stop;
1233 setverdict(pass);
1234 };
1235
1236 control {
1237     execute(configOperRunning1());
1238     execute(configOperRunning2());
1239     execute(configOperConnectMtc());
1240     execute(configOperConnectSelf());
1241     execute(configOperDisconnect());
1242     execute(configOperDone());
1243     execute(configOperArray());
1244     execute(configOperRunningAny());
1245     execute(configOperRunningAll());
1246     execute(configOperDoneAny());
1247     execute(configOperDoneAny2());
1248     execute(configOperDoneAny3());
1249     execute(configOperDoneAll());
1250     execute(configOperStopAll());
1251     execute(configOperAutostop1());
1252     execute(configOperAutostop2());
1253
1254     execute(configOperRunningAlive_alive());
1255     execute(configOperRunningAliveKill_alive());
1256     execute(configOperRunningAliveKillMixed_alive());
1257     execute(configOperRunningAliveKillKilledMixed_alive());
1258     execute(configOperConnectMtc_alive());
1259     execute(configOperConnectSelf_alive());
1260     execute(configOperDisconnect_alive());
1261     execute(configOperArray_alive());
1262     execute(configOperRunningAny_alive());
1263     execute(configOperRunningAll_alive());
1264     execute(configOperAliveAny_alive());
1265     execute(configOperAliveAll_alive());
1266     execute(configOperDone_alive());
1267     execute(configOperDone2_alive());
1268     execute(configOperDoneAny_alive());
1269     execute(configOperDoneAny2_alive());
1270     execute(configOperDoneAll_alive());
1271     execute(configOperDoneAll2_alive());
1272     execute(configOperKilled_alive());
1273     execute(configOperKilledAny_alive());
1274     execute(configOperKilledAll_alive());
1275     execute(configOperStopAll_alive());
1276     execute(configOperKillAll_alive());
1277     execute(configOperAutoStopAndKill_alive());
1278     execute(configOperAutoStopAndKill2_alive());
1279
1280     execute(InterleaveStatem1());
1281     execute(InterleaveStatem2());
1282     execute(InterleaveStatem3());
1283     execute(InterleaveStatem4());
1284     execute(InterleaveStatem5());
1285     execute(configOperConnectDisconnect());
1286     execute(configOperMapUnmap());
1287 }
1288 }
1289