Merge github.com:eclipse/titan.core

[deliverable/titan.core.git] / regression_test / basicStatem / TbasicStatem.ttcn

/******************************************************************************
 * Copyright (c) 2000-2016 Ericsson Telecom AB
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Balasko, Jeno
 *   Baranyi, Botond
 *   Gecse, Roland
 *   Harai, Tibor
 *   Kovacs, Ferenc
 *   Raduly, Csaba
 *   Szabo, Janos Zoltan – initial implementation
 *
 ******************************************************************************/
module TbasicStatem {
type component basicStatem_mycomp {};


testcase basicStatemIf() runs on basicStatem_mycomp {
// literal constants in the expression
if (true) {setverdict(pass)}
 else {setverdict(fail)}
if (false) {setverdict(fail)}
 else {setverdict(pass)}
// variable references in the expression
var boolean b := true;
if (b) {setverdict(pass)}
 else {setverdict(fail)}
b := false;
if (b) {setverdict(fail)}
 else {setverdict(pass)}
}

testcase basicStatemElseIf() runs on basicStatem_mycomp {
// literal constants in the expressions
if (false) {setverdict(fail)}
 else if (false) {setverdict(fail)}
 else {setverdict(pass)}
if (false) {setverdict(fail)}
 else if (true) {setverdict(pass)}
 else {setverdict(fail)}
if (true) {setverdict(pass)}
 else if (false) {setverdict(fail)}
 else {setverdict(fail)}
// variable references in the expressions
var boolean b1 := false, b2 := false;
if (b1) {setverdict(fail)}
 else if (b2) {setverdict(fail)}
 else {setverdict(pass)}
b2 := true;
if (b1) {setverdict(fail)}
 else if (b2) {setverdict(pass)}
 else {setverdict(fail)}
b1 := true;
if (b1) {setverdict(pass)}
 else if (b2) {setverdict(fail)}
 else {setverdict(fail)}
}

type record address { integer filed }

testcase basicStatemSelectCase() runs on basicStatem_mycomp {
var bitstring bit1, bit2;
bit1:='1001'B;
bit2:='11001'B;
select (bit1) {
 case ('11'B,'101000101'B) { setverdict(fail); }
 case ('1001'B,bit2,'10'B) { setverdict(pass); }
 case else { setverdict(inconc); }
}
var boolean boo1, boo2;
boo1:=false;
boo2:=true;
select (boo1) {
 case (true,boo2) { setverdict(fail); }
 case (false)     { setverdict(pass); }
 case else { setverdict(inconc); }
}
var charstring char1, char2;
char1:="A";
char2:="cvs";
select (char1) {
 case ("lkjsd",char2) { setverdict(fail); }
 case ("ff","C","A") { setverdict(pass); }
 case else { setverdict(inconc); }
}
var universal charstring uchar1, uchar2;
uchar1:=char(0,0,1,113);
uchar2:=char(0,0,0,129);
select (uchar1) {
 case (uchar2,char(0,0,0,67)) { setverdict(fail); }
 case (char(0,0,0,69),char(0,0,0,68),char(0,0,1,113)) { setverdict(pass); }
 case else { setverdict(inconc); }
}
var integer int1, int2;
int1:= 4;
int2:= 7;
select (int1) {
 case (3,0) { setverdict(fail); }
 case (11,int2,4) { setverdict(pass); }
 case else { setverdict(inconc); }
}
var octetstring octet1, octet2;
octet1:= 'A9'O;
octet2:= '1267FD'O;
select (octet1) {
 case ('FF'O,'A9'O,octet2) { setverdict(pass); }
 case ('067B'O,'FA'O) { setverdict(fail); }
 case else { setverdict(inconc); }
}
var hexstring hex1, hex2;
hex1:= '12C'H;
hex2:= 'A778F'H;
select (hex1) {
 case ('D'H,'AA'H) { setverdict(fail); }
 case (hex2,'12C'H,'3'H) { setverdict(pass); }
 case else { setverdict(inconc); }
}
var verdicttype verd1, verd2;
verd1:= none;
verd2:= error;
select (verd1) {
 case (pass,fail) { setverdict(fail); }
 case (verd2,none,inconc) { setverdict(pass); }
 case else { setverdict(inconc); }
}
var float float1, float2;
float1:= 2.3;
float2:= 7.89;
select (float1) {
 case (float2,0.4) { setverdict(fail); }
 case (2.31,7.0,2.29) { setverdict(inconc); }
 case else { setverdict(pass); }
}
var address v_add1 := {23};
var address v_add2 := {47};
select (v_add1) {
 case ({56},v_add2) { setverdict(fail); }
 case ({4},{23},{234}) { setverdict(pass); }
 case else { setverdict(inconc); }
}
}

testcase basicStatemFor() runs on basicStatem_mycomp {
var integer i,x1,x2;
x1:=0;
x2:=0;
for (i:=1;i<=10;i:=i+1) {x1:=x1+1};
for (var integer j:=1;j<1000;j:=j*2) {x2:=x2+2;}
if (x1==10) {setverdict(pass);} // index variable declared separately
 else {setverdict(fail);}
if (x2==20) {setverdict(pass);}  // index variable declared in the loop
 else {setverdict(fail);}
}

testcase basicStatemWhile() runs on basicStatem_mycomp {
var integer i,x1,x2;
x1:=0;
x2:=0;
i:=1;
while (i<=10) {i:=i+1; x1:=x1+1};
i:=1
while (i<=0) {i:=i+1; x2:=x2+1};
if (x1==10) {setverdict(pass)}
 else {setverdict(fail)};
if (x2==0) {setverdict(pass)} // zero-sized loop
 else {setverdict(fail)};

}

testcase basicStatemDoWhile() runs on basicStatem_mycomp {
var integer i,x1,x2;
x1:=0;
x2:=0;
i:=1;
do {i:=i+1; x1:=x1+1} while (i<=10);
i:=1;
do {i:=i+1; x2:=x2+1} while (i<=0);
if (x1==10) {setverdict(pass)}
 else {setverdict(fail)};
if (x2==1) {setverdict(pass)}  // "zero-sized" loop
 else {setverdict(fail)};
}

testcase basicStatemLabelGoto1() runs on basicStatem_mycomp {
goto L1;		// forward
setverdict(fail);
label L1;
setverdict(pass);
}

testcase basicStatemLabelGoto2() runs on basicStatem_mycomp {
var integer x;
x:=0
label L1;		// backward
x:=x+1;
if (x==2) {setverdict(pass)}
else { goto L1};
}

testcase basicStatemStop() runs on basicStatem_mycomp {
setverdict(pass);
stop;
setverdict(fail);
}

function f_aliasValue(integer par1, in integer par2, out integer par3,
  inout integer par4, template integer par5)
{
  // all parameters should be zero, par3 is inaccessible yet
  if (par1 == 0 and par2 == 0 and par4 == 0 and valueof(par5) == 0)
    { setverdict(pass); }
  else { setverdict(fail); }
  par3 := 1;
  // par3 and par4 should change to one, the rest should remain zero
  if (par1 == 0 and par2 == 0 and par3 == 1 and par4 == 1 and
      valueof(par5) == 0) { setverdict(pass); }
  else { setverdict(fail); }
  par1 := 2;
  // nothing except par1 should change
  if (par1 == 2 and par2 == 0 and par3 == 1 and par4 == 1 and
      valueof(par5) == 0) { setverdict(pass); }
  else { setverdict(fail); }
}

function f_aliasTemplate(template integer par1, in template integer par2,
  out template integer par3, inout template integer par4, integer par5)
{
  if (valueof(par1) == 0 and valueof(par2) == 0 and valueof(par4) == 0 and
      par5 == 0) { setverdict(pass); }
  else { setverdict(fail); }
  par3 := 1;
  if (valueof(par1) == 0 and valueof(par2) == 0 and valueof(par3) == 1 and
      valueof(par4) == 1 and par5 == 0) { setverdict(pass); }
  else { setverdict(fail); }
  par1 := 2;
  if (valueof(par1) == 2 and valueof(par2) == 0 and valueof(par3) == 1 and
      valueof(par4) == 1 and par5 == 0) { setverdict(pass); }
  else { setverdict(fail); }
}

testcase basicStatemfunctionCallAlias() runs on basicStatem_mycomp
{
  var integer i := 0;
  f_aliasValue(i, i, i, i, i);
  if (i == 1) { setverdict(pass); }
  else { setverdict(fail); }
  var template integer j := 0;
  f_aliasTemplate(j, j, j, j, valueof(j));
  if (valueof(j) == 1) { setverdict(pass); }
  else { setverdict(fail); }
}

type record r_empty { }
type set s_empty { }
type record of r_empty ro_empty
type set of s_empty so_empty
type union u_empty { ro_empty f1, so_empty f2 }
type anytype a_empty
type enumerated e_empty { f1, f2 }
type component c_HM79493
{
  var integer i;                var template integer it
  var float f;                  var template float ft
  var boolean b;                var template boolean bt
  var verdicttype v;            var template verdicttype vt
  var bitstring bs;             var template bitstring bst
  var hexstring hs;             var template hexstring hst
  var octetstring os;           var template octetstring ost
  var charstring cs;            var template charstring cst
  var universal charstring ucs; var template universal charstring ucst
  var c_HM79493 c;              var template c_HM79493 ct
  var r_empty r;                var template r_empty rt
  var s_empty s;                var template s_empty st
  var ro_empty ro;              var template ro_empty rot
  var so_empty so;              var template so_empty sot
  var u_empty u;                var template u_empty ut
  var a_empty a;                var template a_empty at
  var e_empty e;                var template e_empty et
  
  // HQ19911: uncomment and watch the DTE
  // var template ro_empty tro := { permutation({}) }
}

testcase tc_HM79493_set() runs on c_HM79493
{
  i := 100; it := 100
  f := 100.0; ft := 100.0
  b := true; bt := true
  v := pass; vt := pass
  bs := '00'B; bst := '00'B
  hs := '00'H; hst := '00'H
  os := '00'O; ost := '00'O
  cs := "00"; cst := "00"
  ucs := char(0, 0, 0, 0); ucst := char(0, 0, 0, 0)
  c := self; ct := self
  r := { }; rt := { }
  s := { }; st := { }
  ro := { }; rot := { }
  so := { }; sot := { }
  u := { f1 := { } }; ut := { f1 := { } }
  a := { u_empty := { f1 := { } } }; at := { u_empty := { f1 := { } } }
  e := f1; et := f1
  setverdict(pass)
}

testcase tc_HM79493_check() runs on c_HM79493
{
  if (log2str(i) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(it) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(f) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(ft) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(b) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(bt) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(v) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(vt) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(bs) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(bst) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(hs) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(hst) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(os) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(ost) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(cs) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(cst) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(ucs) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(ucst) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(c) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(ct) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(r) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(rt) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(s) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(st) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(ro) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(rot) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(so) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(sot) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(u) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(ut) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(a) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(at) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(e) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
  if (log2str(et) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
}

control {
 execute(basicStatemIf());
 execute(basicStatemElseIf());
 execute(basicStatemSelectCase());
 execute(basicStatemFor());
 execute(basicStatemWhile());
 execute(basicStatemDoWhile());
 execute(basicStatemLabelGoto1());
 execute(basicStatemLabelGoto2());
 execute(basicStatemStop());
 //execute(basicStatemfunctionCallAlias());
 execute(tc_HM79493_set());  // Set component variables/variable templates.
 execute(tc_HM79493_check());  // All component variables/variable templates must be unbound.
}
} with { extension "anytype u_empty" }