regression_test/configOper/TconfigOper.ttcn

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