regression_test/verdictOper/TverdictOper.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  *   Godar, Marton
  11  *   Kovacs, Ferenc
  12  *   Raduly, Csaba
  13  *   Szabados, Kristof
  14  *   Szabo, Janos Zoltan – initial implementation
  15  *
  16  ******************************************************************************/
  17 module TverdictOper
  18 { type component verdictOper_mycomp {};
  19   const verdicttype verdictOper_const1:=fail;
  20
  21 testcase verdictAssign() runs on verdictOper_mycomp {
  22  var verdicttype x1:=inconc;
  23  var verdicttype x2;
  24  x2:=pass;
  25  if (x1==inconc) {setverdict(pass);}    //at declaration
  26      else {setverdict(fail);}
  27  if (x2==pass) {setverdict(pass);}      //later
  28      else {setverdict(fail);}
  29 }
  30
  31 testcase verdictConst() runs on verdictOper_mycomp {
  32  const verdicttype const1:=inconc;
  33  if (verdictOper_const1==fail) {setverdict(pass);}      //definition part declaration
  34      else {setverdict(fail);}
  35  if (const1==inconc) {setverdict(pass);}        //testcase
  36      else {setverdict(fail);}
  37 }
  38
  39
  40 testcase verdictCompEq() runs on verdictOper_mycomp {
  41 var verdicttype x1,x2,x3;
  42   x1:=pass;
  43   x2:=pass;
  44   x3:=inconc;
  45   if (x1==x2) {setverdict(pass);}       //variable_variable
  46    else {setverdict(fail);}
  47   if (not(x3==x2)) {setverdict(pass);}  //variable_variable
  48    else {setverdict(fail);}
  49   if (x1==pass) {setverdict(pass);}     //variable_value
  50    else {setverdict(fail);}
  51   if (not(x1==fail)) {setverdict(pass);}        //variable_value
  52    else {setverdict(fail);}
  53   if (pass==x1) {setverdict(pass);}     //value_variable
  54    else {setverdict(fail);}
  55   if (not(inconc==x1)) {setverdict(pass);}      //value_variable
  56    else {setverdict(fail);}
  57   if (pass==pass) {setverdict(pass);}   //value_value
  58    else {setverdict(fail);}
  59   if (not(pass==fail)) {setverdict(pass);}      //value_value
  60    else {setverdict(fail);}
  61 }
  62
  63 testcase verdictCompNotEq() runs on verdictOper_mycomp
  64 { var verdicttype x1,x2,x3;
  65   x1:=pass;
  66   x2:=fail;
  67   x3:=pass;
  68   if (x1!=x2) {setverdict(pass);}       //variable_variable
  69    else {setverdict(fail);}
  70   if (not(x1!=x3)) {setverdict(pass);}  //variable_variable
  71    else {setverdict(fail);}
  72   if (x1!=fail) {setverdict(pass);}     //variable_value
  73    else {setverdict(fail);}
  74   if (not(x1!=pass)) {setverdict(pass);}        //variable_value
  75    else {setverdict(fail);}
  76   if (pass!=x2) {setverdict(pass);}     //value_variable
  77    else {setverdict(fail);}
  78   if (not(fail!=x2)) {setverdict(pass);}        //value_variable
  79    else {setverdict(fail);}
  80   if (inconc!=fail) {setverdict(pass);} //value_value
  81    else {setverdict(fail);}
  82   if (not(pass!=pass)) {setverdict(pass);}      //value_value
  83    else {setverdict(fail);}
  84 }
  85
  86 testcase verdictSetGet() runs on verdictOper_mycomp {
  87  var verdicttype x1;
  88  if (getverdict != none) { setverdict(fail); stop; }
  89  setverdict(pass);
  90  x1 := getverdict;
  91  if (x1 != pass) { setverdict(fail); stop; }
  92 }
  93
  94 testcase verdictSet_None() runs on verdictOper_mycomp {
  95  // do nothing
  96 }
  97
  98 testcase verdictSet_n_None() runs on verdictOper_mycomp {
  99  setverdict(none);
 100 }
 101
 102 testcase verdictSet_p_Pass() runs on verdictOper_mycomp {
 103  setverdict(pass);
 104 }
 105
 106 testcase verdictSet_i_Inconc() runs on verdictOper_mycomp {
 107  setverdict(inconc);
 108 }
 109
 110 testcase verdictSet_f_Fail() runs on verdictOper_mycomp {
 111  setverdict(fail, "fail alone is fail");
 112 }
 113
 114 testcase verdictSet_p_i_Inconc() runs on verdictOper_mycomp {
 115  setverdict(pass);
 116  setverdict(inconc);
 117 }
 118
 119 testcase verdictSet_p_f_Fail() runs on verdictOper_mycomp {
 120  setverdict(pass);
 121  setverdict(fail, "fail after pass is fail");
 122 }
 123
 124 testcase verdictSet_p_n_Pass() runs on verdictOper_mycomp {
 125  setverdict(pass);
 126  setverdict(none);
 127 }
 128
 129 testcase verdictSet_i_p_Inconc() runs on verdictOper_mycomp {
 130  setverdict(inconc);
 131  setverdict(pass);
 132 }
 133
 134 testcase verdictSet_i_f_Fail() runs on verdictOper_mycomp {
 135  setverdict(inconc);
 136  setverdict(fail);
 137 }
 138
 139 testcase verdictSet_i_n_Inconc() runs on verdictOper_mycomp {
 140  setverdict(inconc);
 141  setverdict(none);
 142 }
 143
 144 testcase verdictSet_f_p_Fail() runs on verdictOper_mycomp {
 145  setverdict(fail);
 146  setverdict(pass, "pass after fail is still fail");
 147 }
 148
 149 testcase verdictSet_f_i_Fail() runs on verdictOper_mycomp {
 150  setverdict(fail);
 151  setverdict(inconc);
 152 }
 153
 154 testcase verdictSet_f_n_Fail() runs on verdictOper_mycomp {
 155  setverdict(fail);
 156  setverdict(none);
 157 }
 158
 159 testcase verdictSet_n_p_Pass() runs on verdictOper_mycomp {
 160  setverdict(none);
 161  setverdict(pass);
 162 }
 163
 164 testcase verdictSet_n_i_Inconc() runs on verdictOper_mycomp {
 165  setverdict(none);
 166  setverdict(inconc);
 167 }
 168
 169 testcase verdictSet_n_f_Fail() runs on verdictOper_mycomp {
 170  setverdict(none);
 171  setverdict(fail);
 172 }
 173
 174 /*--- VERDICT REASON -----------------------------------------------*/
 175
 176 modulepar octetstring VR_mp := '12353425'O;
 177 const float VR_fl := 1.0;
 178 type record VR_rec {
 179         integer i,
 180         boolean b
 181 }
 182
 183 testcase verdict_reason() runs on verdictOper_mycomp {
 184
 185         template VR_rec VR_tmpl := { i := 1235, b := true};
 186         var integer VR_int := 5;
 187         var boolean VR_bool;
 188         timer VR_timer := 5.0;
 189         VR_timer.start;
 190
 191         setverdict(pass, "Module parameter identifier: ", VR_mp);
 192         setverdict(pass, "Literal value: ", "this is the value");
 193         setverdict(pass, "Data constant identifier: ", VR_fl);
 194         setverdict(pass, "Template instance: ", VR_tmpl);
 195         setverdict(pass, "Data type variable identifier: ", VR_int);
 196         setverdict(pass, "Uninitialized data type variable identifier: ", VR_bool);
 197         setverdict(pass, "self component type variable identifier: ", self);
 198         setverdict(pass, "mtc component type variable identifier: ", mtc);
 199         setverdict(pass, "system component type variable identifier: ", system);
 200         setverdict(pass, "Timer running operation: ", VR_timer.running);
 201         setverdict(pass, "Timer name: ", VR_timer);
 202         setverdict(pass, "Getverdict operation: ", getverdict);
 203         setverdict(pass, "More parameters: ", getverdict, system, self, VR_tmpl, VR_mp, "and this is the and of all logging...");
 204         setverdict(pass);
 205 }
 206
 207 type verdicttype typedefbasic_myverdt;
 208 type verdicttype myv1 (pass, fail, none, inconc)
 209 type myv1 myv2
 210 type verdicttype myv3 (error)
 211 type verdicttype myv4 (myv1, myv3)
 212 const myv1 c_myv1 := pass
 213 const myv4 c_myv2 := none
 214 template myv1 t_myv1 := f_v1()
 215 template myv1 t_myv2 := f_v2()
 216 template myv4 t_myv3 := fail
 217
 218 modulepar myv1 mod1 := c_myv1
 219
 220 function f_v1() return myv1 { return inconc }
 221 function f_v2() return myv1 { return c_myv1 }
 222
 223 testcase verdictSubtypes() runs on verdictOper_mycomp {
 224   if (pass == mod1 and mod1 == pass and f_v1() != f_v2()) { setverdict(pass) }
 225   else { setverdict(fail) }
 226   var template myv3 vt_v1 := error
 227   var myv3 v_v1 := valueof(vt_v1)
 228   if (error == v_v1 and match(error, vt_v1)) { setverdict(pass) }
 229   else { setverdict(fail) }
 230 }
 231
 232 testcase verdictIsbound() runs on verdictOper_mycomp {
 233   var verdicttype v0;
 234   var verdicttype v1 := pass;
 235   if ( isvalue(v0) ) { setverdict(fail); } else { setverdict(pass); };
 236   if ( isvalue(v1) ) { setverdict(pass); } else { setverdict(fail); };
 237 }
 238
 239 control{
 240  var integer fault_count := 0;
 241  if (execute(verdictAssign()) != pass) {
 242   log("Test case verdictAssign has unexpected verdict.");
 243   fault_count := fault_count + 1;
 244  }
 245  if (execute(verdictConst()) != pass) {
 246   log("Test case verdictConst has unexpected verdict.");
 247   fault_count := fault_count + 1;
 248  }
 249  if (execute(verdictCompEq()) != pass) {
 250   log("Test case verdictCompEq has unexpected verdict.");
 251   fault_count := fault_count + 1;
 252  }
 253  if (execute(verdictCompNotEq()) != pass) {
 254   log("Test case verdictCompNotEq has unexpected verdict.");
 255   fault_count := fault_count + 1;
 256  }
 257  if (execute(verdictSetGet()) != pass) {
 258   log("Test case verdictSetGet has unexpected verdict.");
 259   fault_count := fault_count + 1;
 260  }
 261  if (execute(verdictSet_None()) != none) {
 262   log("Test case verdictSet_None has unexpected verdict.");
 263   fault_count := fault_count + 1;
 264  }
 265  if (execute(verdictSet_n_None()) != none) {
 266   log("Test case verdictSet_n_None has unexpected verdict.");
 267   fault_count := fault_count + 1;
 268  }
 269  if (execute(verdictSet_p_Pass()) != pass) {
 270   log("Test case verdictSet_p_Pass has unexpected verdict.");
 271   fault_count := fault_count + 1;
 272  }
 273  if (execute(verdictSet_i_Inconc()) != inconc) {
 274   log("Test case verdictSet_i_Inconc has unexpected verdict.");
 275   fault_count := fault_count + 1;
 276  }
 277  if (execute(verdictSet_f_Fail()) != fail) {
 278   log("Test case verdictSet_f_Fail has unexpected verdict.");
 279   fault_count := fault_count + 1;
 280  }
 281  if (execute(verdictSet_p_i_Inconc()) != inconc) {
 282   log("Test case verdictSet_p_i_Inconc has unexpected verdict.");
 283   fault_count := fault_count + 1;
 284  }
 285  if (execute(verdictSet_p_f_Fail()) != fail) {
 286   log("Test case verdictSet_p_f_Fail has unexpected verdict.");
 287   fault_count := fault_count + 1;
 288  }
 289  if (execute(verdictSet_p_n_Pass()) != pass) {
 290   log("Test case verdictSet_p_n_Pass has unexpected verdict.");
 291   fault_count := fault_count + 1;
 292  }
 293  if (execute(verdictSet_i_p_Inconc()) != inconc) {
 294   log("Test case verdictSet_i_p_Inconc has unexpected verdict.");
 295   fault_count := fault_count + 1;
 296  }
 297  if (execute(verdictSet_i_f_Fail()) != fail) {
 298   log("Test case verdictSet_i_f_Fail has unexpected verdict.");
 299   fault_count := fault_count + 1;
 300  }
 301  if (execute(verdictSet_i_n_Inconc()) != inconc) {
 302   log("Test case verdictSet_i_n_Inconc has unexpected verdict.");
 303   fault_count := fault_count + 1;
 304  }
 305  if (execute(verdictSet_f_p_Fail()) != fail) {
 306   log("Test case verdictSet_f_p_Fail has unexpected verdict.");
 307   fault_count := fault_count + 1;
 308  }
 309  if (execute(verdictSet_f_i_Fail()) != fail) {
 310   log("Test case verdictSet_f_i_Fail has unexpected verdict.");
 311   fault_count := fault_count + 1;
 312  }
 313  if (execute(verdictSet_f_n_Fail()) != fail) {
 314   log("Test case verdictSet_f_n_Fail has unexpected verdict.");
 315   fault_count := fault_count + 1;
 316  }
 317  if (execute(verdictSet_n_p_Pass()) != pass) {
 318   log("Test case verdictSet_n_p_Pass has unexpected verdict.");
 319   fault_count := fault_count + 1;
 320  }
 321  if (execute(verdictSet_n_i_Inconc()) != inconc) {
 322   log("Test case verdictSet_n_i_Inconc has unexpected verdict.");
 323   fault_count := fault_count + 1;
 324  }
 325  if (execute(verdictSet_n_f_Fail()) != fail) {
 326   log("Test case verdictSet_n_f_Fail has unexpected verdict.");
 327   fault_count := fault_count + 1;
 328  }
 329  if (execute(verdict_reason()) != pass) {
 330   log("Test case verdict_reason has unexpected verdict.");
 331   fault_count := fault_count + 1;
 332  }
 333  if (execute(verdictSubtypes()) != pass) {
 334   log("Test case verdictSubtypes() has unexpected verdict.");
 335   fault_count := fault_count + 1;
 336   }
 337  if (execute(verdictIsbound()) != pass) {
 338   log("Test case verdictSubtypes() has unexpected verdict.");
 339   fault_count := fault_count + 1;
 340  }
 341  if (fault_count == 0) {
 342   log("ALL TEST CASES HAVE PASSED!!!");
 343  } else {
 344   var integer i := 0;
 345   log("NUMBER OF FAILED TEST CASES: ", fault_count);
 346   // this will cause an error
 347   i := 1 / i;
 348  }
 349  }
 350 }