regression_test/commMessage/TcommMessage.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  *   Bartha, Norbert
  11  *   Delic, Adam
  12  *   Dimitrov, Peter
  13  *   Forstner, Matyas
  14  *   Koppany, Csaba
  15  *   Kovacs, Ferenc
  16  *   Raduly, Csaba
  17  *   Szabados, Kristof
  18  *   Szabo, Janos Zoltan – initial implementation
  19  *
  20  ******************************************************************************/
  21 module TcommMessage {
  22
  23 import from ImplMsgEncData all;
  24
  25 type enumerated commMessage_tenum {exx1,exx2,exx3};
  26 type record commMessage_trecord {
  27         integer x1 optional,
  28         float x2 };
  29 type record of octetstring commMessage_trecof;
  30 type set commMessage_tset {
  31         integer x1,
  32         float x2 optional };
  33 type set of charstring commMessage_tsetof;
  34 type union commMessage_tunion {
  35         integer x1,
  36         float x2 };
  37 type integer commMessage_tarray[3][2];
  38
  39 template commMessage_trecord commMessage_temp1 :={
  40  x1:=(2,4,6),
  41  x2:=(1.2 .. 2.1) };
  42
  43 template commMessage_trecord commMessage_temp2(integer xt) :={
  44  x1:=xt,
  45  x2:=(1.2 .. 2.1) };
  46
  47 template commMessage_tarray commMessage_temp3:= {{1,1},{2,2},{3,3}};
  48
  49 type port commMessage_port1 message
  50 { inout integer } with { extension "internal" };
  51
  52 //port for testing of sending different types
  53 type port commMessage_port2 message
  54 { inout float, boolean, bitstring, octetstring, charstring, commMessage_tenum, commMessage_trecord,commMessage_trecof, commMessage_tsetof, commMessage_tset, commMessage_tunion, commMessage_tarray
  55 } with { extension "internal" };
  56
  57 type commMessage_port2 commMessage_port2Alias; // testing type alias on components
  58 type component C { } // testing type alias on components
  59 type C C2;
  60
  61 type component commMessage_comp1 {
  62  port commMessage_port1 Port1;
  63  var integer xx1;
  64  };
  65
  66 type component commMessage_comp2 {
  67  port commMessage_port1 Port2[5];
  68  var integer xx2;
  69  };
  70
  71 type component commMessage_comp3 {
  72  port commMessage_port2 Port3;
  73  var integer xx3;
  74  };
  75
  76 type component commMessage_comp4 {
  77  port commMessage_port2 Port4[5];
  78  var integer xx4;
  79  };
  80
  81 type component commInterPTC_comp1 {
  82   port commMessage_port2 Port1;
  83   port commMessage_port2 Port2;
  84  };
  85
  86 type record R { // to check referencing optional component members
  87   C f optional
  88 }
  89
  90 function checkOptionalComponent(inout R par) {// to check referencing optional component members
  91   par.f := C.create;
  92   if (par.f.running or par.f.alive) { }
  93   par.f.stop;
  94   par.f.kill;
  95   par.f.done;
  96   par.f.killed;
  97 }
  98
  99 function commMessage_behav1(integer xxx) runs on commMessage_comp1 {
 100                                 //sends back x+param
 101 while (true) {
 102   Port1.receive(integer:?) -> value xx1;
 103   xx1:=xx1+xxx;
 104   Port1.send(xx1);
 105 }
 106 };
 107
 108 function commMessage_behav2() runs on commMessage_comp3 {
 109 var charstring xchar;                   // sends back x
 110 var float xfloat;
 111 var boolean xbool;
 112 var bitstring xbitstr;
 113 var octetstring xoctetstr;
 114 var charstring xcharstr;
 115 var commMessage_tenum xenum;
 116 var commMessage_trecord xrecord;
 117 var commMessage_trecof xrecof;
 118 var commMessage_tset xset;
 119 var commMessage_tsetof xsetof;
 120 var commMessage_tunion xunion;
 121 var commMessage_tarray xarray;
 122 alt {
 123  [] Port3.receive(charstring:?) -> value xchar {Port3.send(xchar)} ;
 124  [] Port3.receive(float:?) -> value xfloat {Port3.send(xfloat)} ;
 125  [] Port3.receive(boolean:?) -> value xbool {Port3.send(xbool)} ;
 126  [] Port3.receive(bitstring:?) -> value xbitstr {Port3.send(xbitstr)} ;
 127  [] Port3.receive(octetstring:?) -> value xoctetstr {Port3.send(xoctetstr)} ;
 128  [] Port3.receive(charstring:?) -> value xcharstr {Port3.send(xcharstr)} ;
 129  [] Port3.receive(commMessage_tenum:?) -> value xenum {Port3.send(xenum)} ;
 130  [] Port3.receive(commMessage_trecord:?) -> value xrecord {Port3.send(xrecord); repeat; } ;
 131  [] Port3.receive(commMessage_trecof:?) -> value xrecof {Port3.send(xrecof)} ;
 132  [] Port3.receive(commMessage_tset:?) -> value xset {Port3.send(xset)} ;
 133  [] Port3.receive(commMessage_tsetof:?) -> value xsetof {Port3.send(xsetof)} ;
 134  [] Port3.receive(commMessage_tunion:?) -> value xunion {Port3.send(xunion)} ;
 135  [] Port3.receive(commMessage_tarray:?) -> value xarray {Port3.send(xarray)} ;
 136 };
 137 };
 138
 139 testcase commMessageIntegerEncode() runs on commMessage_comp1
 140 {
 141     const integer values[8] := { 0, 1, -1, 10000, -100000, 2147483647,
 142         -2147483647, -2147483646 };
 143     var commMessage_comp1 ptc;
 144     timer T1 := 1.0;
 145     for (var integer i := 0; i < 8; i := i + 1) {
 146         ptc := commMessage_comp1.create;
 147         connect(self:Port1, ptc:Port1);
 148         ptc.start(commMessage_behav1(values[i]));
 149         Port1.send(0);
 150         T1.start;
 151         alt {
 152         [] Port1.receive(values[i]) { T1.stop; setverdict(pass); }
 153         [] Port1.receive { T1.stop; setverdict(fail); }
 154         [] T1.timeout { setverdict(fail); }
 155         }
 156         disconnect(self:Port1, ptc:Port1);
 157         ptc.stop;
 158     }
 159     ptc := commMessage_comp1.create;
 160     connect(self:Port1, ptc:Port1);
 161     ptc.start(commMessage_behav1(0));
 162     for (var integer i := 0; i < 8; i := i + 1) {
 163         Port1.send(values[i]);
 164         T1.start;
 165         alt {
 166         [] Port1.receive(values[i]) { T1.stop; setverdict(pass); }
 167         [] Port1.receive { T1.stop; setverdict(fail); }
 168         [] T1.timeout { setverdict(fail); }
 169         }
 170     }
 171     disconnect(self:Port1, ptc:Port1);
 172     ptc.stop;
 173 }
 174
 175 testcase commMessageValue() runs on commMessage_comp2 {
 176 var commMessage_comp1 comp[5];   // sending and receiving of data, value checked
 177 var integer xxint;
 178 var integer i;
 179 for (i:=0; i<5; i:=i+1)
 180 { log(i);
 181   comp[i]:=commMessage_comp1.create;
 182   comp[i].start(commMessage_behav1(i));
 183   connect(self:Port2[i],comp[i]:Port1);
 184   xxint:=5;
 185   Port2[i].send(xxint);
 186   Port2[i].receive(integer:?) -> value xxint;
 187   if (xxint==5+i) {setverdict(pass)}
 188     else {setverdict(fail)};
 189 }
 190 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 191 };
 192
 193 testcase commMessageReceiveAny() runs on commMessage_comp2 {
 194 var commMessage_comp1 comp[5];   // receive any message
 195 var commMessage_comp1 xxadr;
 196 timer T1:=1.0;
 197 var integer xxint;
 198 var integer i;
 199 for (i:=0; i<5; i:=i+1)
 200 { log(i);
 201   comp[i]:=commMessage_comp1.create;
 202   comp[i].start(commMessage_behav1(i));
 203   connect(self:Port2[i],comp[i]:Port1);
 204   xxint:=5;
 205   Port2[i].send(xxint);
 206   if(T1.running) {T1.stop};
 207   T1.start;
 208   alt {
 209    [] Port2[i].receive -> sender xxadr {setverdict(pass)};
 210    [] T1.timeout  {setverdict(fail)};
 211    }
 212 }
 213 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 214 };
 215
 216 testcase commMessageReceiveAnyPort() runs on commMessage_comp2 {
 217 var commMessage_comp1 comp[5];   // receive message on any port
 218 timer T1:=1.0;
 219 var integer xxint;
 220 var integer i;
 221 for (i:=0; i<5; i:=i+1)
 222 { log(i);
 223   comp[i]:=commMessage_comp1.create;
 224   comp[i].start(commMessage_behav1(i));
 225   connect(self:Port2[i],comp[i]:Port1);
 226 }
 227   xxint:=5;
 228   Port2[2].send(xxint);
 229   if(T1.running) {T1.stop};
 230   T1.start;
 231   alt {
 232 //   [] any port.receive(xxint+2) {setverdict(pass)};
 233    [] any port.receive {setverdict(pass)};
 234    [] T1.timeout  {setverdict(fail)};
 235    }
 236 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 237 };
 238
 239 testcase commMessageTo() runs on commMessage_comp2 {
 240 var commMessage_comp1 comp[5];   // sending data to a given partner
 241 var integer xxint;
 242 var integer i;
 243 for (i:=0; i<5; i:=i+1)
 244 { log(i);
 245   comp[i]:=commMessage_comp1.create;
 246   comp[i].start(commMessage_behav1(i));
 247   connect(self:Port2[0],comp[i]:Port1); // connect all of the ptc-s to the same port
 248 }
 249   xxint:=5;
 250   Port2[0].send(xxint) to comp[3];
 251   Port2[0].receive(integer:?) -> value xxint;
 252   if (xxint==5+3) {setverdict(pass)}
 253     else {setverdict(fail)};
 254 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 255 };
 256
 257 testcase commMessageSender1() runs on commMessage_comp2 {
 258 var commMessage_comp1 comp[5];   // storing sender (component type)
 259 var commMessage_comp1 xxcomp;
 260 var integer xxint;
 261 var integer i;
 262 for (i:=0; i<5; i:=i+1)
 263 { log(i);
 264   comp[i]:=commMessage_comp1.create;
 265   comp[i].start(commMessage_behav1(i));
 266   connect(self:Port2[0],comp[i]:Port1); // connect all of the ptc-s to the same port
 267 }
 268 for (i:=0; i<5; i:=i+1)
 269 {  xxint:=5;
 270   Port2[0].send(xxint) to comp[i];
 271   Port2[0].receive(integer:?) -> value xxint sender xxcomp;
 272   if (xxcomp==comp[i]) {setverdict(pass)}
 273     else {setverdict(fail)};
 274   if (xxint==5+i) {setverdict(pass)}
 275     else {setverdict(fail)};
 276 }
 277 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 278 };
 279
 280 testcase commMessageSender2() runs on commMessage_comp2 {
 281 var commMessage_comp1 comp[5];   // storing sender
 282 var commMessage_comp1 xxaddr;
 283 var integer xxint;
 284 var integer i;
 285 for (i:=0; i<5; i:=i+1)
 286 { log(i);
 287   comp[i]:=commMessage_comp1.create;
 288   comp[i].start(commMessage_behav1(i));
 289   connect(self:Port2[0],comp[i]:Port1); // connect all of the ptc-s to the same port
 290 }
 291 for (i:=0; i<5; i:=i+1)
 292 { xxint:=5;
 293   Port2[0].send(xxint) to comp[i];
 294   Port2[0].receive(integer:?) -> sender xxaddr;
 295   xxint:=5;
 296   Port2[0].send(xxint) to xxaddr;
 297   Port2[0].receive(integer:?) -> value xxint;
 298   if (xxint==i+5) {setverdict(pass)}
 299     else {setverdict(fail)};
 300 }
 301 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 302 };
 303
 304
 305 testcase commMessageFrom() runs on commMessage_comp2 {
 306 var commMessage_comp1 comp[5];   // receiving data from a given partner
 307 timer T1:=1.0;
 308 var integer xxint;
 309 var integer i;
 310 for (i:=0; i<5; i:=i+1)
 311 { log(i);
 312   comp[i]:=commMessage_comp1.create;
 313   comp[i].start(commMessage_behav1(i));
 314   connect(self:Port2[0],comp[i]:Port1); // connect all of the ptc-s to the same port
 315 }
 316   xxint:=5;
 317 for (i:=0; i<5; i:=i+1) {   Port2[0].send(xxint) to comp[i]; }
 318 if(T1.running) {T1.stop};
 319 T1.start;
 320 alt {
 321   [] Port2[0].receive(integer:?) from comp[3] -> value xxint {};
 322   [] Port2[0].receive(integer:?) {repeat};
 323   [] T1.timeout {setverdict(fail)};
 324 }
 325 if (xxint==5+3) {setverdict(pass)}
 326    else {setverdict(fail)};
 327 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 328 };
 329
 330 testcase commMessageTemplate1() runs on commMessage_comp4 {
 331 var commMessage_comp3 comp[5];   // receiving with template
 332 timer T1:=0.5;
 333 var integer temp1,temp2;
 334 temp1:=2;
 335 var commMessage_trecord xxrecord:={x1:=temp1, x2:=1.2} ;
 336 var integer i;
 337 for (i:=0; i<5; i:=i+1)
 338 { log(i);
 339   comp[i]:=commMessage_comp3.create;
 340   comp[i].start(commMessage_behav2());
 341   connect(self:Port4[i],comp[i]:Port3);
 342   Port4[i].send(xxrecord);              // matching
 343   if(T1.running) {T1.stop};
 344   T1.start;
 345   alt {
 346     [] Port4[i].receive(commMessage_temp1) -> value xxrecord {};
 347     [] T1.timeout {setverdict(fail)};
 348    }
 349   temp2:=xxrecord.x1;
 350   if (temp2==2) {setverdict(pass)}
 351     else {setverdict(fail)};
 352   if (xxrecord.x2==1.2) {setverdict(pass)}
 353     else {setverdict(fail)};
 354 }
 355 xxrecord.x2:=3.1;
 356 for (i:=0; i<5; i:=i+1) {    // not matching
 357   Port4[i].send(xxrecord);
 358   if(T1.running) {T1.stop};
 359   T1.start;
 360   alt {
 361     [] Port4[i].receive(commMessage_temp1) -> value xxrecord {setverdict(fail)};
 362     [] T1.timeout {setverdict(pass)};
 363    }
 364 }
 365 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 366 };
 367
 368
 369 testcase commMessageTemplate2() runs on commMessage_comp4 {
 370 var commMessage_comp3 comp[5];   // receiving with parametrized template
 371 timer T1:=0.5;
 372 var integer temp1,temp2;
 373 temp1:=2;
 374 var commMessage_trecord xxrecord:={x1:=temp1, x2:=1.2} ;
 375 var integer i;
 376 for (i:=0; i<5; i:=i+1)
 377 { log(i);
 378   comp[i]:=commMessage_comp3.create;
 379   comp[i].start(commMessage_behav2());
 380   connect(self:Port4[i],comp[i]:Port3);
 381   Port4[i].send(xxrecord);              // matching
 382   if(T1.running) {T1.stop};
 383   T1.start;
 384   alt {
 385     [] Port4[i].receive(commMessage_temp2(2)) -> value xxrecord {};
 386 //    [] Port4[i].receive(commMessage_temp1) -> value xxrecord {};
 387     [] T1.timeout {setverdict(fail)};
 388    }
 389   temp2:=xxrecord.x1;
 390   if (temp2==2) {setverdict(pass)}
 391     else {setverdict(fail)};
 392   if (xxrecord.x2==1.2) {setverdict(pass)}
 393     else {setverdict(fail)};
 394 }
 395 xxrecord.x2:=3.1;
 396 for (i:=0; i<5; i:=i+1) {    // not matching
 397   Port4[i].send(xxrecord);
 398   if(T1.running) {T1.stop};
 399   T1.start;
 400   alt {
 401 //    [] Port4[i].receive(commMessage_temp2(2)) -> value xxrecord {setverdict(fail)};
 402     [] Port4[i].receive(commMessage_temp1) -> value xxrecord {setverdict(fail)};
 403     [] T1.timeout {setverdict(pass)};
 404    }
 405 }
 406 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 407 };
 408
 409 testcase commMessageTrigger() runs on commMessage_comp2 {
 410 var commMessage_comp1 comp[5];   // trigger operation
 411 timer T1:=1.0;
 412 var integer xxint;
 413 var integer i;
 414 for (i:=0; i<5; i:=i+1)
 415 { log(i);
 416   comp[i]:=commMessage_comp1.create;
 417   comp[i].start(commMessage_behav1(i));
 418   connect(self:Port2[0],comp[i]:Port1); // connects all ptc-s to one port
 419 };
 420   xxint:=5;
 421 for (i:=0; i<5; i:=i+1) {
 422   Port2[0].send(xxint) to comp[i];
 423 };
 424 if(T1.running) {T1.stop};
 425 T1.start;
 426 alt {
 427   [] Port2[0].trigger(integer:7)  {setverdict(pass)};
 428   [] T1.timeout {setverdict(fail)};
 429   }
 430 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 431 };
 432
 433 testcase commMessageTriggerValue() runs on commMessage_comp2 {
 434 var commMessage_comp1 comp[5];   // trigger operation, values checked
 435 timer T1:=1.0;
 436 var integer xxint;
 437 var integer i;
 438 for (i:=0; i<5; i:=i+1)
 439 { log(i);
 440   comp[i]:=commMessage_comp1.create;
 441   comp[i].start(commMessage_behav1(i));
 442   connect(self:Port2[0],comp[i]:Port1); // connects all ptc-s to one port
 443 };
 444   xxint:=5;
 445 for (i:=0; i<5; i:=i+1) {
 446   Port2[0].send(xxint) to comp[i];
 447 };
 448 if(T1.running) {T1.stop};
 449 T1.start;
 450 alt {
 451   [] Port2[0].trigger(integer:7) -> value xxint {setverdict(pass)};
 452   [] T1.timeout {setverdict(fail)};
 453   }
 454 if (xxint==7) {setverdict(pass)}
 455     else {setverdict(fail)};
 456 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 457 };
 458
 459 testcase commMessageTriggerAny() runs on commMessage_comp2 {
 460 var commMessage_comp1 comp[5];   // trigger any message
 461 var commMessage_comp1 xxadr;
 462 timer T1:=1.0;
 463 var integer xxint;
 464 var integer i;
 465 for (i:=0; i<5; i:=i+1)
 466 { log(i);
 467   comp[i]:=commMessage_comp1.create;
 468   comp[i].start(commMessage_behav1(i));
 469   connect(self:Port2[i],comp[i]:Port1);
 470   xxint:=5;
 471   Port2[i].send(xxint);
 472   if(T1.running) {T1.stop};
 473   T1.start;
 474   alt {
 475    [] Port2[i].trigger -> sender xxadr {setverdict(pass)};
 476    [] T1.timeout  {setverdict(fail)};
 477    }
 478 }
 479 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 480 };
 481
 482 testcase commMessageTriggerAnyPort() runs on commMessage_comp2 {
 483 var commMessage_comp1 comp[5];   // trigger message on any port
 484 timer T1:=1.0;
 485 var integer xxint;
 486 var integer i;
 487 for (i:=0; i<5; i:=i+1)
 488 { log(i);
 489   comp[i]:=commMessage_comp1.create;
 490   comp[i].start(commMessage_behav1(i));
 491   connect(self:Port2[i],comp[i]:Port1);
 492 }
 493   xxint:=5;
 494   Port2[2].send(xxint);
 495   if(T1.running) {T1.stop};
 496   T1.start;
 497   alt {
 498 //   [] any port.trigger(xxint+2) {setverdict(pass)};
 499    [] any port.trigger {setverdict(pass)};
 500    [] T1.timeout  {setverdict(fail)};
 501    }
 502 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 503 };
 504
 505 testcase commMessageTriggerSender1() runs on commMessage_comp2 {
 506 var commMessage_comp1 comp[5];   // trigger, storing sender (component type)
 507 var commMessage_comp1 xxcomp;
 508 var integer xxint;
 509 var integer i;
 510 for (i:=0; i<5; i:=i+1)
 511 { log(i);
 512   comp[i]:=commMessage_comp1.create;
 513   comp[i].start(commMessage_behav1(i));
 514   connect(self:Port2[0],comp[i]:Port1); // connect all of the ptc-s to the same port
 515 }
 516 for (i:=0; i<5; i:=i+1) {
 517   xxint:=5;
 518   Port2[0].send(xxint) to comp[i];
 519   Port2[0].trigger(integer:?) -> value xxint sender xxcomp;
 520   if (xxcomp==comp[i]) {setverdict(pass)}
 521     else {setverdict(fail)};
 522   if (xxint==5+i) {setverdict(pass)}
 523     else {setverdict(fail)};
 524 }
 525 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 526 };
 527
 528 testcase commMessageTriggerSender2() runs on commMessage_comp2 {
 529 var commMessage_comp1 comp[5];   // trigger, storing sender
 530 var commMessage_comp1 xxaddr;
 531 var integer xxint;
 532 var integer i;
 533 for (i:=0; i<5; i:=i+1)
 534 { log(i);
 535   comp[i]:=commMessage_comp1.create;
 536   comp[i].start(commMessage_behav1(i));
 537   connect(self:Port2[0],comp[i]:Port1); // connect all of the ptc-s to the same port
 538 }
 539 for (i:=0; i<5; i:=i+1) {
 540   xxint:=5;
 541   Port2[0].send(xxint) to comp[i];
 542   Port2[0].trigger(integer:?) -> sender xxaddr;
 543   xxint:=5;
 544   Port2[0].send(xxint) to xxaddr;
 545   Port2[0].trigger(integer:?) -> value xxint;
 546   if (xxint==5+i) {setverdict(pass)}
 547     else {setverdict(fail)};
 548 }
 549 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 550 };
 551
 552
 553 testcase commMessageTriggerFrom() runs on commMessage_comp2 {
 554 var commMessage_comp1 comp[5];   // trigger, from a given partner
 555 timer T1:=1.0;
 556 var integer xxint;
 557 var integer i;
 558 for (i:=0; i<5; i:=i+1)
 559 { log(i);
 560   comp[i]:=commMessage_comp1.create;
 561   comp[i].start(commMessage_behav1(i));
 562   connect(self:Port2[0],comp[i]:Port1); // connect all of the ptc-s to the same port
 563 }
 564   xxint:=5;
 565 for (i:=0; i<5; i:=i+1) {   Port2[0].send(xxint) to comp[i]; }
 566 if(T1.running) {T1.stop};
 567 T1.start;
 568 alt {
 569   [] Port2[0].trigger(integer:?) from comp[3] -> value xxint {};
 570 //  [] Port2[0].receive(integer:?) {repeat};
 571   [] T1.timeout {setverdict(fail)};
 572 }
 573 if (xxint==5+3) {setverdict(pass)}
 574    else {setverdict(fail)};
 575 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 576 };
 577
 578 testcase commMessageTriggerTemplate1() runs on commMessage_comp4 {
 579 var commMessage_comp3 comp[5];   // trigger with template
 580 timer T1:=0.5;
 581 var integer temp1,temp2;
 582 temp1:=2;
 583 var commMessage_trecord xxrecord:={x1:=temp1, x2:=1.2} ;
 584 var integer i;
 585 for (i:=0; i<5; i:=i+1)
 586 { log(i);
 587   comp[i]:=commMessage_comp3.create;
 588   comp[i].start(commMessage_behav2());
 589   connect(self:Port4[i],comp[i]:Port3);
 590   Port4[i].send(xxrecord);              // matching
 591   if(T1.running) {T1.stop};
 592   T1.start;
 593   alt {
 594     [] Port4[i].trigger(commMessage_temp1) -> value xxrecord {};
 595  //   [] Port4[i].receive(commMessage_trecord:?) -> value xxrecord {};
 596     [] T1.timeout {setverdict(fail)};
 597    }
 598   temp2:=xxrecord.x1;
 599   if (temp2==2) {setverdict(pass)}
 600     else {setverdict(fail)};
 601   if (xxrecord.x2==1.2) {setverdict(pass)}
 602     else {setverdict(fail)};
 603 }
 604 xxrecord.x2:=3.1;
 605 for (i:=0; i<5; i:=i+1) {    // not matching
 606   Port4[i].send(xxrecord);
 607   if(T1.running) {T1.stop};
 608   T1.start;
 609   alt {
 610     [] Port4[i].trigger(commMessage_temp1) -> value xxrecord {setverdict(fail)};
 611     [] T1.timeout {setverdict(pass)};
 612    }
 613 }
 614 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 615 };
 616
 617
 618 testcase commMessageTriggerTemplate2() runs on commMessage_comp4 {
 619 var commMessage_comp3 comp[5];   // trigger with parametrized template
 620 timer T1:=0.5;
 621 var integer temp1,temp2;
 622 temp1:=2;
 623 var commMessage_trecord xxrecord:={x1:=temp1, x2:=1.2} ;
 624 var integer i;
 625 for (i:=0; i<5; i:=i+1)
 626 { log(i);
 627   comp[i]:=commMessage_comp3.create;
 628   comp[i].start(commMessage_behav2());
 629   connect(self:Port4[i],comp[i]:Port3);
 630   Port4[i].send(xxrecord);              // matching
 631   if(T1.running) {T1.stop};
 632   T1.start;
 633   alt {
 634 //    [] Port4[i].trigger(commMessage_temp2(2)) -> value xxrecord {};
 635     [] Port4[i].trigger(commMessage_temp1) -> value xxrecord {};
 636     [] T1.timeout {setverdict(fail)};
 637    }
 638   temp2:=xxrecord.x1;
 639   if (temp2==2) {setverdict(pass)}
 640     else {setverdict(fail)};
 641   if (xxrecord.x2==1.2) {setverdict(pass)}
 642     else {setverdict(fail)};
 643 }
 644 xxrecord.x2:=3.1;
 645 for (i:=0; i<5; i:=i+1) {    // not matching
 646   Port4[i].send(xxrecord);
 647   if(T1.running) {T1.stop};
 648   T1.start;
 649   alt {
 650 //    [] Port4[i].trigger(commMessage_temp2(2)) -> value xxrecord {setverdict(fail)};
 651     [] Port4[i].trigger(commMessage_temp1) -> value xxrecord {setverdict(fail)};
 652     [] T1.timeout {setverdict(pass)};
 653    }
 654 }
 655 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 656 };
 657
 658 //*****************************************************************
 659
 660 testcase commMessageChar() runs on commMessage_comp4 {
 661 var commMessage_comp3 comp[5];   // sending and receiving of char type
 662 var charstring xxchar:="a";
 663 var integer i;
 664 for (i:=0; i<5; i:=i+1)
 665 { log(i);
 666   comp[i]:=commMessage_comp3.create;
 667   comp[i].start(commMessage_behav2());
 668   connect(self:Port4[i],comp[i]:Port3);
 669   Port4[i].send(xxchar);
 670   xxchar:="b";
 671   Port4[i].receive(charstring:?) -> value xxchar;
 672   if (xxchar=="a") {setverdict(pass)}
 673     else {setverdict(fail)};
 674 }
 675 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 676 };
 677
 678 testcase commMessageFloat() runs on commMessage_comp4 {
 679 var commMessage_comp3 comp[5];   // sending and receiving of float type
 680 var float xxfloat:=1.23;
 681 var integer i;
 682 for (i:=0; i<5; i:=i+1)
 683 { log(i);
 684   comp[i]:=commMessage_comp3.create;
 685   comp[i].start(commMessage_behav2());
 686   connect(self:Port4[i],comp[i]:Port3);
 687   Port4[i].send(xxfloat);
 688   xxfloat:=123.5;
 689   Port4[i].receive(float:?) -> value xxfloat;
 690   if (xxfloat==1.23) {setverdict(pass)}
 691     else {setverdict(fail)};
 692 }
 693 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 694 };
 695
 696 testcase commMessageBool() runs on commMessage_comp4 {
 697 var commMessage_comp3 comp[5];   // sending and receiving of boolean type
 698 var boolean xxbool:=true;
 699 var integer i;
 700 for (i:=0; i<5; i:=i+1)
 701 { log(i);
 702   comp[i]:=commMessage_comp3.create;
 703   comp[i].start(commMessage_behav2());
 704   connect(self:Port4[i],comp[i]:Port3);
 705   Port4[i].send(xxbool);
 706   xxbool:=false;
 707   Port4[i].receive(boolean:?) -> value xxbool;
 708   if (xxbool==true) {setverdict(pass)}
 709     else {setverdict(fail)};
 710 }
 711 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 712 };
 713
 714 testcase commMessageBitstr() runs on commMessage_comp4 {
 715 var commMessage_comp3 comp[5];   // sending and receiving of bitstring type
 716 var bitstring xxbitstr:='0101'B;
 717 var integer i;
 718 for (i:=0; i<5; i:=i+1)
 719 { log(i);
 720   comp[i]:=commMessage_comp3.create;
 721   comp[i].start(commMessage_behav2());
 722   connect(self:Port4[i],comp[i]:Port3);
 723   Port4[i].send(xxbitstr);
 724   xxbitstr:='0000'B;
 725   Port4[i].receive(bitstring:?) -> value xxbitstr;
 726   if (xxbitstr=='0101'B) {setverdict(pass)}
 727     else {setverdict(fail)};
 728 }
 729 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 730 };
 731
 732
 733 testcase commMessageOctetstr() runs on commMessage_comp4 {
 734 var commMessage_comp3 comp[5];   // sending and receiving of octetstring type
 735 var octetstring xxoctetstr:='01AB'O;
 736 var integer i;
 737 for (i:=0; i<5; i:=i+1)
 738 { log(i);
 739   comp[i]:=commMessage_comp3.create;
 740   comp[i].start(commMessage_behav2());
 741   connect(self:Port4[i],comp[i]:Port3);
 742   Port4[i].send(xxoctetstr);
 743   xxoctetstr:='0000'O;
 744   Port4[i].receive(octetstring:?) -> value xxoctetstr;
 745   if (xxoctetstr=='01AB'O) {setverdict(pass)}
 746     else {setverdict(fail)};
 747 }
 748 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 749 };
 750
 751
 752 testcase commMessageCharstr() runs on commMessage_comp4 {
 753 var commMessage_comp3 comp[5];   // sending and receiving of charstring type
 754 var charstring xxcharstr:="abcd";
 755 var integer i;
 756 for (i:=0; i<5; i:=i+1)
 757 { log(i);
 758   comp[i]:=commMessage_comp3.create;
 759   comp[i].start(commMessage_behav2());
 760   connect(self:Port4[i],comp[i]:Port3);
 761   Port4[i].send(xxcharstr);
 762   xxcharstr:="aaaa";
 763   Port4[i].receive(charstring:?) -> value xxcharstr;
 764   if (xxcharstr=="abcd") {setverdict(pass)}
 765     else {setverdict(fail)};
 766 }
 767 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 768 };
 769
 770 testcase commMessageEnum() runs on commMessage_comp4 {
 771 var commMessage_comp3 comp[5];   // sending and receiving of enumerated type
 772 var commMessage_tenum xxenum:=exx1;
 773 var integer i;
 774 for (i:=0; i<5; i:=i+1)
 775 { log(i);
 776   comp[i]:=commMessage_comp3.create;
 777   comp[i].start(commMessage_behav2());
 778   connect(self:Port4[i],comp[i]:Port3);
 779   Port4[i].send(xxenum);
 780   xxenum:=exx2;
 781   Port4[i].receive(commMessage_tenum:?) -> value xxenum;
 782   if (xxenum==exx1) {setverdict(pass)}
 783     else {setverdict(fail)};
 784 }
 785 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 786 };
 787
 788 testcase commMessageRecord() runs on commMessage_comp4 {
 789 var commMessage_comp3 comp[5];   // sending and receiving of record type with opt. field
 790 var integer temp1,temp2;
 791 temp1:=1;
 792 var commMessage_trecord xxrecord:={x1:=temp1, x2:=1.2} ;
 793 var integer i;
 794 for (i:=0; i<5; i:=i+1)
 795 { log(i);
 796   comp[i]:=commMessage_comp3.create;
 797   comp[i].start(commMessage_behav2());
 798   connect(self:Port4[i],comp[i]:Port3);
 799   Port4[i].send(xxrecord);
 800   temp2:=2;
 801   xxrecord:={x1:=temp2,x2:=1.4};
 802   Port4[i].receive(commMessage_trecord:?) -> value xxrecord;
 803   temp2:=xxrecord.x1;
 804   if (temp2==1) {setverdict(pass)}
 805     else {setverdict(fail)};
 806   if (xxrecord.x2==1.2) {setverdict(pass)}
 807     else {setverdict(fail)};
 808 }
 809 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 810 };
 811
 812 testcase commMessageRecordOmit() runs on commMessage_comp4 {
 813 var commMessage_comp3 comp[5];   // sending and receiving of record type with omitted field
 814 var integer temp1,temp2;
 815 temp1:=1;
 816 temp2:=2;
 817 var commMessage_trecord xxrecord:={x1:=omit, x2:=1.2} ;
 818 var integer i;
 819 for (i:=0; i<5; i:=i+1)
 820 { log(i);
 821   comp[i]:=commMessage_comp3.create;
 822   comp[i].start(commMessage_behav2());
 823   connect(self:Port4[i],comp[i]:Port3);
 824   Port4[i].send(xxrecord);
 825   xxrecord:={x1:=temp2,x2:=1.4};
 826   Port4[i].receive(commMessage_trecord:?) -> value xxrecord;
 827   if (not(ispresent(xxrecord.x1))) {setverdict(pass)}
 828     else {setverdict(fail)};
 829   if (xxrecord.x2==1.2) {setverdict(pass)}
 830     else {setverdict(fail)};
 831 }
 832 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 833 };
 834
 835 testcase commMessageRecof() runs on commMessage_comp4 {
 836 var commMessage_comp3 comp[5];   // sending and receiving of record of type
 837 var commMessage_trecof xxrecof:={'00AB'O,'AB00'O};
 838 var integer i;
 839 for (i:=0; i<5; i:=i+1)
 840 { log(i);
 841   comp[i]:=commMessage_comp3.create;
 842   comp[i].start(commMessage_behav2());
 843   connect(self:Port4[i],comp[i]:Port3);
 844   Port4[i].send(xxrecof);
 845   xxrecof:={'00'O};
 846   Port4[i].receive(commMessage_trecof:?) -> value xxrecof;
 847   if (xxrecof[0]=='00AB'O) {setverdict(pass)}
 848     else {setverdict(fail)};
 849   if (xxrecof[1]=='AB00'O) {setverdict(pass)}
 850     else {setverdict(fail)};
 851 }
 852 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 853 };
 854
 855
 856 testcase commMessageSet() runs on commMessage_comp4 {
 857 var commMessage_comp3 comp[5];   // sending and receiving of set type with opt. field
 858 var float temp1,temp2;
 859 temp1:=1.2;
 860 var commMessage_tset xxset:={x1:=1, x2:=temp1} ;
 861 var integer i;
 862 for (i:=0; i<5; i:=i+1)
 863 { log(i);
 864   comp[i]:=commMessage_comp3.create;
 865   comp[i].start(commMessage_behav2());
 866   connect(self:Port4[i],comp[i]:Port3);
 867   Port4[i].send(xxset);
 868   temp2:=2.4;
 869   xxset:={x1:=2,x2:=temp2};
 870   Port4[i].receive(commMessage_tset:?) -> value xxset;
 871   temp2:=xxset.x2;
 872   if (xxset.x1==1) {setverdict(pass)}
 873     else {setverdict(fail)};
 874   if (temp2==1.2) {setverdict(pass)}
 875     else {setverdict(fail)};
 876 }
 877 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 878 };
 879
 880 testcase commMessageSetOmit() runs on commMessage_comp4 {
 881 var commMessage_comp3 comp[5];   // sending and receiving of set type with omitted field
 882 var float temp1,temp2;
 883 temp1:=1.2;
 884 var commMessage_tset xxset:={x1:=1, x2:=omit} ;
 885 var integer i;
 886 for (i:=0; i<5; i:=i+1)
 887 { log(i);
 888   comp[i]:=commMessage_comp3.create;
 889   comp[i].start(commMessage_behav2());
 890   connect(self:Port4[i],comp[i]:Port3);
 891   Port4[i].send(xxset);
 892   temp2:=2.4;
 893   xxset:={x1:=2,x2:=temp2};
 894   Port4[i].receive(commMessage_tset:?) -> value xxset;
 895   if (xxset.x1==1) {setverdict(pass)}
 896     else {setverdict(fail)};
 897   if (not(ispresent(xxset.x2))) {setverdict(pass)}
 898     else {setverdict(fail)};
 899 }
 900 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 901 };
 902
 903
 904 testcase commMessageSetof() runs on commMessage_comp4 {
 905 var commMessage_comp3 comp[5];   // sending and receiving of set of type
 906 var commMessage_tsetof xxsetof:={"a","b"};
 907 var integer i;
 908 for (i:=0; i<5; i:=i+1)
 909 { log(i);
 910   comp[i]:=commMessage_comp3.create;
 911   comp[i].start(commMessage_behav2());
 912   connect(self:Port4[i],comp[i]:Port3);
 913   Port4[i].send(xxsetof);
 914   xxsetof:={"k"};
 915   Port4[i].receive(commMessage_tsetof:?) -> value xxsetof;
 916   if (xxsetof[0]=="a") {setverdict(pass)}
 917     else {setverdict(fail)};
 918   if (xxsetof[1]=="b") {setverdict(pass)}
 919     else {setverdict(fail)};
 920 }
 921 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 922 };
 923
 924
 925 testcase commMessageUnion() runs on commMessage_comp4 {
 926 var commMessage_comp3 comp[5];   // sending and receiving of union type
 927 var commMessage_tunion xxunion:={x1:=1};
 928 var integer i;
 929 for (i:=0; i<5; i:=i+1)
 930 { log(i);
 931   comp[i]:=commMessage_comp3.create;
 932   comp[i].start(commMessage_behav2());
 933   connect(self:Port4[i],comp[i]:Port3);
 934   Port4[i].send(xxunion);
 935   xxunion:={x2:=1.3};
 936   Port4[i].receive(commMessage_tunion:?) -> value xxunion;
 937   if (xxunion.x1==1) {setverdict(pass)}
 938     else {setverdict(fail)};
 939   if (ischosen(xxunion.x1)) {setverdict(pass)}
 940     else {setverdict(fail)};
 941   if (not(ischosen(xxunion.x2))) {setverdict(pass)}
 942     else {setverdict(fail)};
 943 }
 944 for (i:=0; i<5; i:=i+1) {comp[i].stop};
 945 };
 946
 947 testcase commMessageArray() runs on commMessage_comp4 {
 948   var commMessage_comp3 comp[5];   // sending and receiving of array type
 949   var commMessage_tarray xxarray:={{1,1},{2,2},{3,3}};
 950   var integer i;
 951   for (i:=0; i<5; i:=i+1)
 952   { log(i);
 953     comp[i]:=commMessage_comp3.create;
 954     comp[i].start(commMessage_behav2());
 955     connect(self:Port4[i],comp[i]:Port3);
 956     Port4[i].send(xxarray);
 957     xxarray[0][1]:=10;
 958     Port4[i].receive(commMessage_tarray:?) -> value xxarray;
 959     if(match(xxarray,commMessage_temp3))
 960     {setverdict(pass)}
 961     else
 962     {setverdict(fail)};
 963   }
 964   for (i:=0; i<5; i:=i+1) {comp[i].stop};
 965 };
 966
 967 testcase commMessageInterPTCLocalConnection1() runs on commInterPTC_comp1 {
 968   var charstring vl_char := "a";
 969   var float vl_float := 1.23;
 970   var boolean vl_bool := true;
 971   var bitstring vl_bitstr := '0101'B;
 972   var octetstring vl_octetstr := '01AB'O;
 973   var charstring vl_charstr := "abcd";
 974   var commMessage_tenum vl_enum := exx1;
 975   var commMessage_trecord vl_record := { x1 := 1, x2 := 1.2 };
 976   var commMessage_trecof vl_recof := { '00AB'O, 'AB00'O };
 977   var commMessage_tset vl_set := { x1 := 1, x2 := 1.2 };
 978   var commMessage_tsetof vl_setof := { "a", "b" };
 979   var commMessage_tunion vl_union := { x1:=1 };
 980   var commMessage_tarray vl_array := {{1,1},{2,2},{3,3}};
 981
 982   var charstring vl_xchar;
 983   var float vl_xfloat;
 984   var boolean vl_xbool;
 985   var bitstring vl_xbitstr;
 986   var octetstring vl_xoctetstr;
 987   var charstring vl_xcharstr;
 988   var commMessage_tenum vl_xenum;
 989   var commMessage_trecord vl_xrecord;
 990   var commMessage_trecof vl_xrecof;
 991   var commMessage_tset vl_xset;
 992   var commMessage_tsetof vl_xsetof;
 993   var commMessage_tunion vl_xunion;
 994   var commMessage_tarray vl_xarray;
 995
 996   timer Tl_t := 0.5;
 997
 998   connect(self:Port1,self:Port2);
 999
1000   Port2.send(vl_char);
1001   Tl_t.start;
1002         alt {
1003         [] Port1.receive(charstring: ?) -> value vl_xchar
1004     { Tl_t.stop;
1005       if(vl_xchar == vl_char) { setverdict(pass); }
1006       else { setverdict(fail); }
1007     }
1008         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1009         [] Tl_t.timeout { setverdict(fail); }
1010         }
1011
1012   Port2.send(vl_float);
1013   Tl_t.start;
1014         alt {
1015         [] Port1.receive(float: ?) -> value vl_xfloat
1016     { Tl_t.stop;
1017       if(vl_xfloat == vl_float) { setverdict(pass); }
1018       else { setverdict(fail); }
1019     }
1020         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1021         [] Tl_t.timeout { setverdict(fail); }
1022         }
1023
1024   Port2.send(vl_bool);
1025   Tl_t.start;
1026         alt {
1027         [] Port1.receive(boolean: ?) -> value vl_xbool
1028     { Tl_t.stop;
1029       if(vl_xbool == vl_bool) { setverdict(pass); }
1030       else { setverdict(fail); }
1031     }
1032         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1033         [] Tl_t.timeout { setverdict(fail); }
1034         }
1035
1036   Port2.send(vl_bitstr);
1037   Tl_t.start;
1038         alt {
1039         [] Port1.receive(bitstring: ?) -> value vl_xbitstr
1040     { Tl_t.stop;
1041       if(vl_xbitstr == vl_bitstr) { setverdict(pass); }
1042       else { setverdict(fail); }
1043     }
1044         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1045         [] Tl_t.timeout { setverdict(fail); }
1046         }
1047
1048   Port2.send(vl_octetstr);
1049   Tl_t.start;
1050         alt {
1051         [] Port1.receive(octetstring: ?) -> value vl_xoctetstr
1052     { Tl_t.stop;
1053       if(vl_xoctetstr == vl_octetstr) { setverdict(pass); }
1054       else { setverdict(fail); }
1055     }
1056         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1057         [] Tl_t.timeout { setverdict(fail); }
1058         }
1059
1060   Port2.send(vl_charstr);
1061   Tl_t.start;
1062         alt {
1063         [] Port1.receive(charstring: ?) -> value vl_xcharstr
1064     { Tl_t.stop;
1065       if(vl_xcharstr == vl_charstr) { setverdict(pass); }
1066       else { setverdict(fail); }
1067     }
1068         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1069         [] Tl_t.timeout { setverdict(fail); }
1070         }
1071
1072   Port2.send(vl_enum);
1073   Tl_t.start;
1074         alt {
1075         [] Port1.receive(commMessage_tenum: ?) -> value vl_xenum
1076     { Tl_t.stop;
1077       if(vl_xenum == vl_enum) { setverdict(pass); }
1078       else { setverdict(fail); }
1079     }
1080         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1081         [] Tl_t.timeout { setverdict(fail); }
1082         }
1083
1084   Port2.send(vl_record);
1085   Tl_t.start;
1086         alt {
1087         [] Port1.receive(commMessage_trecord: ?) -> value vl_xrecord
1088     { Tl_t.stop;
1089       if(vl_xrecord == vl_record) { setverdict(pass); }
1090       else { setverdict(fail); }
1091     }
1092         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1093         [] Tl_t.timeout { setverdict(fail); }
1094         }
1095
1096   Port2.send(vl_recof);
1097   Tl_t.start;
1098         alt {
1099         [] Port1.receive(commMessage_trecof: ?) -> value vl_xrecof
1100     { Tl_t.stop;
1101       if(vl_xrecof == vl_recof) { setverdict(pass); }
1102       else { setverdict(fail); }
1103     }
1104         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1105         [] Tl_t.timeout { setverdict(fail); }
1106         }
1107
1108   Port2.send(vl_set);
1109   Tl_t.start;
1110         alt {
1111         [] Port1.receive(commMessage_tset: ?) -> value vl_xset
1112     { Tl_t.stop;
1113       if(vl_xset == vl_set) { setverdict(pass); }
1114       else { setverdict(fail); }
1115     }
1116         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1117         [] Tl_t.timeout { setverdict(fail); }
1118         }
1119
1120   Port2.send(vl_setof);
1121   Tl_t.start;
1122         alt {
1123         [] Port1.receive(commMessage_tsetof: ?) -> value vl_xsetof
1124     { Tl_t.stop;
1125       if(vl_xsetof == vl_setof) { setverdict(pass); }
1126       else { setverdict(fail); }
1127     }
1128         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1129         [] Tl_t.timeout { setverdict(fail); }
1130         }
1131
1132   Port2.send(vl_union);
1133   Tl_t.start;
1134         alt {
1135         [] Port1.receive(commMessage_tunion: ?) -> value vl_xunion
1136     { Tl_t.stop;
1137       if(vl_xunion == vl_union) { setverdict(pass); }
1138       else { setverdict(fail); }
1139     }
1140         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1141         [] Tl_t.timeout { setverdict(fail); }
1142         }
1143
1144   Port2.send(vl_array);
1145   Tl_t.start;
1146         alt {
1147         [] Port1.receive(commMessage_tarray: ?) -> value vl_xarray
1148     { Tl_t.stop;
1149       if(vl_xarray == vl_array) { setverdict(pass); }
1150       else { setverdict(fail); }
1151     }
1152         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1153         [] Tl_t.timeout { setverdict(fail); }
1154         }
1155 }
1156
1157 testcase commMessageInterPTCLocalConnection2() runs on commInterPTC_comp1 {
1158   var charstring vl_char := "a";
1159   var float vl_float := 1.23;
1160   var boolean vl_bool := true;
1161   var bitstring vl_bitstr := '0101'B;
1162   var octetstring vl_octetstr := '01AB'O;
1163   var charstring vl_charstr := "abcd";
1164   var commMessage_tenum vl_enum := exx1;
1165   var commMessage_trecord vl_record := { x1 := 1, x2 := 1.2 };
1166   var commMessage_trecof vl_recof := { '00AB'O, 'AB00'O };
1167   var commMessage_tset vl_set := { x1 := 1, x2 := 1.2 };
1168   var commMessage_tsetof vl_setof := { "a", "b" };
1169   var commMessage_tunion vl_union := { x1:=1 };
1170   var commMessage_tarray vl_array := {{1,1},{2,2},{3,3}};
1171
1172   var charstring vl_xchar;
1173   var float vl_xfloat;
1174   var boolean vl_xbool;
1175   var bitstring vl_xbitstr;
1176   var octetstring vl_xoctetstr;
1177   var charstring vl_xcharstr;
1178   var commMessage_tenum vl_xenum;
1179   var commMessage_trecord vl_xrecord;
1180   var commMessage_trecof vl_xrecof;
1181   var commMessage_tset vl_xset;
1182   var commMessage_tsetof vl_xsetof;
1183   var commMessage_tunion vl_xunion;
1184   var commMessage_tarray vl_xarray;
1185
1186   timer Tl_t := 0.5;
1187
1188   connect(self:Port1,self:Port1);
1189
1190   Port1.send(vl_char);
1191   Tl_t.start;
1192         alt {
1193         [] Port1.receive(charstring: ?) -> value vl_xchar
1194     { Tl_t.stop;
1195       if(vl_xchar == vl_char) { setverdict(pass); }
1196       else { setverdict(fail); }
1197     }
1198         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1199         [] Tl_t.timeout { setverdict(fail); }
1200         }
1201
1202   Port1.send(vl_float);
1203   Tl_t.start;
1204         alt {
1205         [] Port1.receive(float: ?) -> value vl_xfloat
1206     { Tl_t.stop;
1207       if(vl_xfloat == vl_float) { setverdict(pass); }
1208       else { setverdict(fail); }
1209     }
1210         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1211         [] Tl_t.timeout { setverdict(fail); }
1212         }
1213
1214   Port1.send(vl_bool);
1215   Tl_t.start;
1216         alt {
1217         [] Port1.receive(boolean: ?) -> value vl_xbool
1218     { Tl_t.stop;
1219       if(vl_xbool == vl_bool) { setverdict(pass); }
1220       else { setverdict(fail); }
1221     }
1222         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1223         [] Tl_t.timeout { setverdict(fail); }
1224         }
1225
1226   Port1.send(vl_bitstr);
1227   Tl_t.start;
1228         alt {
1229         [] Port1.receive(bitstring: ?) -> value vl_xbitstr
1230     { Tl_t.stop;
1231       if(vl_xbitstr == vl_bitstr) { setverdict(pass); }
1232       else { setverdict(fail); }
1233     }
1234         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1235         [] Tl_t.timeout { setverdict(fail); }
1236         }
1237
1238   Port1.send(vl_octetstr);
1239   Tl_t.start;
1240         alt {
1241         [] Port1.receive(octetstring: ?) -> value vl_xoctetstr
1242     { Tl_t.stop;
1243       if(vl_xoctetstr == vl_octetstr) { setverdict(pass); }
1244       else { setverdict(fail); }
1245     }
1246         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1247         [] Tl_t.timeout { setverdict(fail); }
1248         }
1249
1250   Port1.send(vl_charstr);
1251   Tl_t.start;
1252         alt {
1253         [] Port1.receive(charstring: ?) -> value vl_xcharstr
1254     { Tl_t.stop;
1255       if(vl_xcharstr == vl_charstr) { setverdict(pass); }
1256       else { setverdict(fail); }
1257     }
1258         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1259         [] Tl_t.timeout { setverdict(fail); }
1260         }
1261
1262   Port1.send(vl_enum);
1263   Tl_t.start;
1264         alt {
1265         [] Port1.receive(commMessage_tenum: ?) -> value vl_xenum
1266     { Tl_t.stop;
1267       if(vl_xenum == vl_enum) { setverdict(pass); }
1268       else { setverdict(fail); }
1269     }
1270         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1271         [] Tl_t.timeout { setverdict(fail); }
1272         }
1273
1274   Port1.send(vl_record);
1275   Tl_t.start;
1276         alt {
1277         [] Port1.receive(commMessage_trecord: ?) -> value vl_xrecord
1278     { Tl_t.stop;
1279       if(vl_xrecord == vl_record) { setverdict(pass); }
1280       else { setverdict(fail); }
1281     }
1282         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1283         [] Tl_t.timeout { setverdict(fail); }
1284         }
1285
1286   Port1.send(vl_recof);
1287   Tl_t.start;
1288         alt {
1289         [] Port1.receive(commMessage_trecof: ?) -> value vl_xrecof
1290     { Tl_t.stop;
1291       if(vl_xrecof == vl_recof) { setverdict(pass); }
1292       else { setverdict(fail); }
1293     }
1294         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1295         [] Tl_t.timeout { setverdict(fail); }
1296         }
1297
1298   Port1.send(vl_set);
1299   Tl_t.start;
1300         alt {
1301         [] Port1.receive(commMessage_tset: ?) -> value vl_xset
1302     { Tl_t.stop;
1303       if(vl_xset == vl_set) { setverdict(pass); }
1304       else { setverdict(fail); }
1305     }
1306         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1307         [] Tl_t.timeout { setverdict(fail); }
1308         }
1309
1310   Port1.send(vl_setof);
1311   Tl_t.start;
1312         alt {
1313         [] Port1.receive(commMessage_tsetof: ?) -> value vl_xsetof
1314     { Tl_t.stop;
1315       if(vl_xsetof == vl_setof) { setverdict(pass); }
1316       else { setverdict(fail); }
1317     }
1318         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1319         [] Tl_t.timeout { setverdict(fail); }
1320         }
1321
1322   Port1.send(vl_union);
1323   Tl_t.start;
1324         alt {
1325         [] Port1.receive(commMessage_tunion: ?) -> value vl_xunion
1326     { Tl_t.stop;
1327       if(vl_xunion == vl_union) { setverdict(pass); }
1328       else { setverdict(fail); }
1329     }
1330         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1331         [] Tl_t.timeout { setverdict(fail); }
1332         }
1333
1334   Port1.send(vl_array);
1335   Tl_t.start;
1336         alt {
1337         [] Port1.receive(commMessage_tarray: ?) -> value vl_xarray
1338     { Tl_t.stop;
1339       if(vl_xarray == vl_array) { setverdict(pass); }
1340       else { setverdict(fail); }
1341     }
1342         [] Port1.receive { Tl_t.stop; setverdict(fail); }
1343         [] Tl_t.timeout { setverdict(fail); }
1344         }
1345 }
1346
1347 ////////////////////////////////////////////////////////////////////////////////
1348 // Tests for implicit message encoding: dual faced ports
1349
1350 external function encodePDU1(in PDU1 pdu) return octetstring
1351   with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1352 external function encodePDU2(in PDU2 pdu) return octetstring
1353   with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
1354
1355 external function decodePDU1(in octetstring os, out PDU1 pdu) return integer
1356   with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
1357 external function decodePDU2(in octetstring os, out PDU2 pdu) return integer
1358   with { extension "prototype(backtrack) decode(BER:BER_ACCEPT_ALL) errorbehavior(ALL:WARNING)" }
1359
1360 type port OctStrPort message {
1361   inout octetstring
1362 } with { extension "internal" }
1363
1364 type port LowLevelPort message {
1365   inout octetstring
1366 } with { extension "internal provider" }
1367
1368 type port HighLevelPort message {
1369   inout PDU1;
1370   inout PDU2;
1371   out integer;
1372   out octetstring;
1373 } with { extension "internal user LowLevelPort
1374   out( PDU1 -> octetstring : function(encodePDU1);
1375        PDU2 -> octetstring : function(encodePDU2);
1376        octetstring -> octetstring : simple;
1377        integer -> - : discard)
1378   in ( octetstring -> PDU1 : function(decodePDU1),
1379                       PDU2 : function(decodePDU2),
1380                       - : discard)"
1381 }
1382
1383 type component ImplicitMessageEncodingComponent {
1384   port HighLevelPort hl_port;
1385   port OctStrPort os_port;
1386 }
1387
1388 testcase commMessageDualFacedPorts1() runs on ImplicitMessageEncodingComponent {
1389   connect(mtc:hl_port,mtc:os_port);
1390   var PDU2 pdu2 := { 1234, '1234567890ABCDEF'O, true }
1391   var PDU1 pdu1 := "uu";
1392   var octetstring enc_pdu1 := encodePDU1(pdu1);
1393   var octetstring enc_pdu2 := encodePDU2(pdu2);
1394   var octetstring recv_os;
1395   timer T;
1396
1397   hl_port.send(pdu2);
1398   T.start(1.0);
1399   alt {
1400     [] os_port.receive(octetstring:?) -> value recv_os {
1401       T.stop;
1402       if (recv_os==enc_pdu2) { setverdict(pass); } else { setverdict(fail); }
1403     }
1404     [] T.timeout { setverdict(fail); }
1405   }
1406
1407   hl_port.send(pdu1);
1408   T.start(1.0);
1409   alt {
1410     [] os_port.receive(octetstring:?) -> value recv_os {
1411       T.stop;
1412       if (recv_os==enc_pdu1) { setverdict(pass); } else { setverdict(fail); }
1413     }
1414     [] T.timeout { setverdict(fail); }
1415   }
1416
1417   disconnect(mtc:hl_port,mtc:os_port);
1418 }
1419
1420 type component RepeaterComponent {
1421   port OctStrPort repeater_port;
1422 }
1423
1424 function fn_repeat() runs on RepeaterComponent {
1425 var octetstring sendmeback;
1426 alt {
1427  [] repeater_port.receive(octetstring:?) -> value sendmeback {
1428    repeater_port.send(sendmeback);
1429    repeat;
1430  }
1431 }
1432 }
1433
1434 testcase commMessageDualFacedPorts2() runs on ImplicitMessageEncodingComponent {
1435   timer T;
1436   var RepeaterComponent rc := RepeaterComponent.create;
1437   rc.start(fn_repeat());
1438   var PDU2 pdu2 := { 1234, '1234567890ABCDEF'O, true }
1439   var PDU2 recv_pdu2;
1440   connect(mtc:hl_port, rc:repeater_port);
1441
1442   hl_port.send(pdu2);
1443   T.start(1.0);
1444   alt {
1445     [] hl_port.receive(PDU2:?) -> value recv_pdu2 {
1446       T.stop;
1447       if (recv_pdu2==pdu2) { setverdict(pass); } else { setverdict(fail); }
1448     }
1449     [] T.timeout { setverdict(fail); }
1450   }
1451
1452   //discard at receiving (cannot be decoded by decodePDU1 & 2)
1453   hl_port.send('AA'O);
1454   T.start(1.0);
1455   alt {
1456     [] hl_port.receive {
1457       T.stop;
1458       setverdict(fail);
1459     }
1460     [] T.timeout { setverdict(pass); }
1461   }
1462   //discard at sending (charstring must be discarded)
1463   hl_port.send(1234);
1464           T.start(1.0);
1465           alt {
1466             [] hl_port.receive {
1467               T.stop;
1468               setverdict(fail);
1469             }
1470     [] T.timeout { setverdict(pass); }
1471   }
1472   disconnect(mtc:hl_port, rc:repeater_port);
1473   rc.stop;
1474 }
1475
1476 control {
1477  execute(commMessageIntegerEncode());
1478  execute(commMessageValue());
1479  execute(commMessageReceiveAny());
1480  execute(commMessageReceiveAnyPort());
1481  execute(commMessageTo());
1482  execute(commMessageSender1());
1483  execute(commMessageSender2());
1484  execute(commMessageFrom());
1485  execute(commMessageTemplate1());
1486  execute(commMessageTemplate2());
1487  execute(commMessageTrigger());
1488  execute(commMessageTriggerValue());
1489  execute(commMessageTriggerAny());
1490  execute(commMessageTriggerAnyPort());
1491  execute(commMessageTriggerSender1());
1492  execute(commMessageTriggerSender2());
1493  execute(commMessageTriggerFrom());
1494  execute(commMessageTriggerTemplate1());
1495  execute(commMessageTriggerTemplate2());
1496  execute(commMessageChar());
1497  execute(commMessageFloat());
1498  execute(commMessageBool());
1499  execute(commMessageBitstr());
1500  execute(commMessageOctetstr());
1501  execute(commMessageCharstr());
1502  execute(commMessageEnum());
1503  execute(commMessageRecord());
1504  execute(commMessageRecordOmit());
1505  execute(commMessageRecof());
1506  execute(commMessageSet());
1507  execute(commMessageSetOmit());
1508  execute(commMessageSetof());
1509  execute(commMessageUnion());
1510  execute(commMessageArray());
1511  execute(commMessageInterPTCLocalConnection1());
1512  execute(commMessageInterPTCLocalConnection2());
1513  execute(commMessageDualFacedPorts1());
1514  execute(commMessageDualFacedPorts2());
1515 }
1516 }