regression_test/verdictOper/TverdictOper.ttcn

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