regression_test/templateInt/TtemplateInt.ttcn

   1 /******************************************************************************
   2  * Copyright (c) 2000-2015 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 TtemplateInt {
   9
  10 import from ImportedTemplates all;
  11
  12 type component templateInt_mycomp {};
  13 type record templateInt_rec {
  14  integer x1,
  15  integer x2,
  16  integer x3 optional };
  17 type integer templateInt_subtype (0..1457664);
  18
  19 template templateInt_rec templateInt_tSpec :={ //specific values
  20  x1:=1,
  21  x2:=2,
  22  x3:=3 };
  23 template templateInt_rec templateInt_tList :={ //specific value and value list
  24  x1:=1,
  25  x2:=(2,3,6),
  26  x3:=3 };
  27 template templateInt_rec templateInt_tComp :={ //specific value and compl. list
  28  x1:=1,
  29  x2:=complement (2,3,6),
  30  x3:=3 };
  31 template templateInt_rec templateInt_tOmit :={ //omitting values
  32  x1:=1,
  33  x2:=2,
  34  x3:=omit } ;
  35 template templateInt_rec templateInt_tAny :={ //specific and any value
  36  x1:=1,
  37  x2:=2,
  38  x3:=? } ;
  39 template templateInt_rec templateInt_tAnyorNone :={ //specific and AnyorNone value
  40  x1:=1,
  41  x2:=2,
  42  x3:=* };
  43 template templateInt_rec templateInt_tRange1 :={ //specific value and Range
  44  x1:=1,
  45  x2:=(2 ..4),
  46  x3:=3 };
  47 template templateInt_rec templateInt_tRange2 :={ //specific value and Range
  48  x1:=1,
  49  x2:=(2 .. 4),
  50  x3:=3 };
  51 template templateInt_rec templateInt_tRange3 :={ //specific value and Range
  52  x1:=1,
  53  x2:=(2 .. infinity),
  54  x3:=3 };
  55 template templateInt_rec templateInt_tRange4 :={ //specific value and Range
  56  x1:=1,
  57  x2:=(-infinity .. 4),
  58  x3:=3 };
  59 template templateInt_rec templateInt_tIfpresent :={ //specific value and ifpresent
  60  x1:=1,
  61  x2:=2,
  62  x3:=3 ifpresent };
  63
  64 testcase templateIntSpec() runs on templateInt_mycomp {
  65 var templateInt_rec x1,x2;              //specific value
  66 x1:={ x1:=1,  x2:=2,  x3:=3 };
  67 x2:={ x1:=2,  x2:=2,  x3:=3 };
  68 //match
  69 if (match(x1,templateInt_tSpec)) {setverdict(pass);}
  70  else {setverdict(fail);}
  71 //no match
  72 if (not(match(x2,templateInt_tSpec))) {setverdict(pass);}
  73  else {setverdict(fail);}
  74 }
  75
  76 testcase templateIntList() runs on templateInt_mycomp {
  77 var templateInt_rec x1,x2,x3;           //value list
  78 x1:={ x1:=1,  x2:=6,  x3:=3 };
  79 x2:={ x1:=1,  x2:=7,  x3:=3 };
  80 x3:={ x1:=2,  x2:=6,  x3:=3 };
  81 //match
  82 if (match(x1,templateInt_tList)) {setverdict(pass);}
  83  else {setverdict(fail);}
  84 //no match: out of list
  85 if (not(match(x2,templateInt_tList))) {setverdict(pass);}
  86  else {setverdict(fail);}
  87 //no match: other field
  88 if (not(match(x3,templateInt_tList))) {setverdict(pass);}
  89  else {setverdict(fail);}
  90 }
  91
  92 testcase templateIntComp() runs on templateInt_mycomp {
  93 var templateInt_rec x1,x2,x3;           //complemented list
  94 x1:={ x1:=1,  x2:=7,  x3:=3 };
  95 x2:={ x1:=1,  x2:=6,  x3:=3 };
  96 x3:={ x1:=2,  x2:=7,  x3:=3 };
  97 //match
  98 if (match(x1,templateInt_tComp)) {setverdict(pass);}
  99  else {setverdict(fail);}
 100 //no match: in the list
 101 if (not(match(x2,templateInt_tComp))) {setverdict(pass);}
 102  else {setverdict(fail);}
 103 //no match: other field
 104 if (not(match(x3,templateInt_tComp))) {setverdict(pass);}
 105  else {setverdict(fail);}
 106 }
 107
 108 testcase templateIntOmit() runs on templateInt_mycomp {
 109 var templateInt_rec x1,x2,x3;           //omitting value
 110 x1:={ x1:=1,  x2:=2,  x3:=omit };
 111 x2:={ x1:=1,  x2:=2,  x3:=3 };
 112 x3:={ x1:=2,  x2:=2,  x3:=omit };
 113 //match
 114 if (match(x1,templateInt_tOmit)) {setverdict(pass);}
 115  else {setverdict(fail);}
 116 //no match: not omitted
 117 if (not(match(x2,templateInt_tOmit))) {setverdict(pass);}
 118  else {setverdict(fail);}
 119 //no match: other field
 120 if (not(match(x3,templateInt_tOmit))) {setverdict(pass);}
 121  else {setverdict(fail);}
 122 }
 123
 124 testcase templateIntAny() runs on templateInt_mycomp {
 125 var templateInt_rec x1,x2,x3;           //any value
 126 x1:={ x1:=1,  x2:=2,  x3:=3 };
 127 x2:={ x1:=1,  x2:=2,  x3:=omit };
 128 x3:={ x1:=2,  x2:=2,  x3:=3 };
 129 //match
 130 if (match(x1,templateInt_tAny)) {setverdict(pass);}
 131  else {setverdict(fail);}
 132 //no match: field omitted
 133 if (not(match(x2,templateInt_tAny))) {setverdict(pass);}
 134  else {setverdict(fail);}
 135 //no match: other field
 136 if (not(match(x3,templateInt_tAny))) {setverdict(pass);}
 137  else {setverdict(fail);}
 138 }
 139
 140 testcase templateIntAnyorNone() runs on templateInt_mycomp {
 141 var templateInt_rec x1,x2,x3;           //AnyorNone value
 142 x1:={ x1:=1,  x2:=2,  x3:=omit };
 143 x2:={ x1:=1,  x2:=2,  x3:=3 };
 144 x3:={ x1:=2,  x2:=2,  x3:=omit };
 145 //match: omitted
 146 if (match(x1,templateInt_tAnyorNone)) {setverdict(pass);}
 147  else {setverdict(fail);}
 148 //match: value
 149 if (match(x2,templateInt_tAnyorNone)) {setverdict(pass);}
 150  else {setverdict(fail);}
 151 //no match: other field
 152 if (not(match(x3,templateInt_tAnyorNone))) {setverdict(pass);}
 153  else {setverdict(fail);}
 154 }
 155
 156 testcase templateIntRange1() runs on templateInt_mycomp {
 157 var templateInt_rec x1,x2,x3;           //Range (x .. y)
 158 x1:={ x1:=1,  x2:=2,  x3:=3 };
 159 x2:={ x1:=1,  x2:=5,  x3:=3 };
 160 x3:={ x1:=2,  x2:=2,  x3:=3 };
 161 //match
 162 if (match(x1,templateInt_tRange1)) {setverdict(pass);}
 163  else {setverdict(fail);}
 164 //no match: out of range
 165 if (not(match(x2,templateInt_tRange1))) {setverdict(pass);}
 166  else {setverdict(fail);}
 167 //no match: other field
 168 if (not(match(x3,templateInt_tRange1))) {setverdict(pass);}
 169  else {setverdict(fail);}
 170 }
 171
 172 testcase templateIntRange2() runs on templateInt_mycomp {
 173 var templateInt_rec x1,x2,x3;           //Range (x to y)
 174 x1:={ x1:=1,  x2:=2,  x3:=3 };
 175 x2:={ x1:=1,  x2:=5,  x3:=3 };
 176 x3:={ x1:=2,  x2:=2,  x3:=3 };
 177 //match
 178 if (match(x1,templateInt_tRange2)) {setverdict(pass);}
 179  else {setverdict(fail);}
 180 //no match: out of range
 181 if (not(match(x2,templateInt_tRange2))) {setverdict(pass);}
 182  else {setverdict(fail);}
 183 //no match: other field
 184 if (not(match(x3,templateInt_tRange2))) {setverdict(pass);}
 185  else {setverdict(fail);}
 186 }
 187
 188 testcase templateIntRange3() runs on templateInt_mycomp {
 189 var templateInt_rec x1,x2,x3;           //Range, with infinity
 190 x1:={ x1:=1,  x2:=8,  x3:=3 };
 191 x2:={ x1:=1,  x2:=-5,  x3:=3 };
 192 x3:={ x1:=2,  x2:=2,  x3:=3 };
 193 //match
 194 if (match(x1,templateInt_tRange3)) {setverdict(pass);}
 195  else {setverdict(fail);}
 196 //no match: out of range
 197 if (not(match(x2,templateInt_tRange3))) {setverdict(pass);}
 198  else {setverdict(fail);}
 199 //no match: other field
 200 if (not(match(x3,templateInt_tRange3))) {setverdict(pass);}
 201  else {setverdict(fail);}
 202 }
 203
 204 testcase templateIntRange4() runs on templateInt_mycomp {
 205 var templateInt_rec x1,x2,x3;           //Range with - infinity
 206 x1:={ x1:=1,  x2:=-2,  x3:=3 };
 207 x2:={ x1:=1,  x2:=5,  x3:=3 };
 208 x3:={ x1:=2,  x2:=2,  x3:=3 };
 209 //match
 210 if (match(x1,templateInt_tRange4)) {setverdict(pass);}
 211  else {setverdict(fail);}
 212 //no match: out of range
 213 if (not(match(x2,templateInt_tRange4))) {setverdict(pass);}
 214  else {setverdict(fail);}
 215 //no match: other field
 216 if (not(match(x3,templateInt_tRange4))) {setverdict(pass);}
 217  else {setverdict(fail);}
 218 }
 219
 220 testcase templateIntIfpresent() runs on templateInt_mycomp {
 221 var templateInt_rec x1,x2,x3,x4;                //ifpresent
 222 x1:={ x1:=1,  x2:=2,  x3:=3 };
 223 x2:={ x1:=1,  x2:=2,  x3:=omit };
 224 x3:={ x1:=1,  x2:=2,  x3:=4 };
 225 x4:={ x1:=2,  x2:=2,  x3:=omit };
 226 //match: present and match
 227 if (match(x1,templateInt_tIfpresent)) {setverdict(pass);}
 228  else {setverdict(fail);}
 229 //match: not present
 230 if (match(x2,templateInt_tIfpresent)) {setverdict(pass);}
 231  else {setverdict(fail);}
 232 //no match: present and not match
 233 if (not(match(x3,templateInt_tIfpresent))) {setverdict(pass);}
 234  else {setverdict(fail);}
 235 //no match: other field
 236 if (not(match(x4,templateInt_tIfpresent))) {setverdict(pass);}
 237  else {setverdict(fail);}
 238 }
 239
 240 // Types for TR_HJ94652.
 241 type record TR_HJ94652_myrec {
 242   integer myrecint
 243 }
 244
 245 template TR_HJ94652_myrec TR_HJ94652_mytemp(integer myint) := {
 246   myrecint := (myint - 100 .. myint)
 247 }
 248
 249 type record of TR_HJ94652_myrec TR_HJ94652_mylist
 250
 251 testcase TR_HJ94652() runs on templateInt_mycomp {
 252   // INTEGER_template::copy_template() was not implemented correctly for
 253   // VALUE_RANGE templates.
 254   var template TR_HJ94652_mylist myownlist := { }
 255   for (var integer i := 1; i <= 3; i := i + 1) {
 256     myownlist[i] := TR_HJ94652_mytemp(i * 100)
 257   }
 258   for (var integer i := 1; i <= 3; i := i + 1) {
 259     var charstring s1 := log2str(myownlist[i])
 260     var charstring s2 := log2str(TR_HJ94652_mytemp(i * 100))
 261     if (s1 == s2) { setverdict(pass) }
 262     else { setverdict(fail) }
 263   }
 264 }
 265
 266 testcase templateIntSubtype() runs on templateInt_mycomp {
 267   // this tests the use of inline templates (value ranges)
 268   // with subtypes and variables
 269   var templateInt_subtype x := 312;
 270   var templateInt_subtype lower_limit := 100;
 271   var templateInt_subtype upper_limit := 65535;
 272   if (not match(x, templateInt_subtype:(0..upper_limit))) { // TR: artf602477
 273     setverdict(fail);
 274   }
 275   if (not match(x, integer:(100..upper_limit))) {
 276     setverdict(fail);
 277   }
 278   if (not match(312, templateInt_subtype:(100..upper_limit))) {
 279     setverdict(fail);
 280   }
 281   if (not match(x, templateInt_subtype:(100..65535))) {
 282     setverdict(fail);
 283   }
 284   if (not match(x, templateInt_subtype:(lower_limit..65535))) {
 285     setverdict(fail);
 286   }
 287   if (not match(x, templateInt_subtype:(lower_limit..upper_limit))) {
 288     setverdict(fail);
 289   }
 290   setverdict(pass);
 291 }
 292
 293 // test case: using a parameterized template with no actual parameters (using default values)
 294 // before its declaration
 295 template integer tReverse := tPard;
 296
 297 template integer tPard(integer p := 6) := p;
 298
 299 testcase templateIntReverseOrder() runs on templateInt_mycomp {
 300   var template integer vtExpected := 6;
 301   if (log2str(tReverse) == log2str(vtExpected)) {
 302     setverdict(pass);
 303   }
 304   else {
 305     setverdict(fail, "Expected: ", vtExpected, ", got: ", tReverse);
 306   }
 307 }
 308
 309 // same test, but the parameterized template is passed as a parameter to
 310 // an imported parameterized template
 311 template integer tReverse2 := tImported(tPard2);
 312
 313 template integer tPard2(integer p := 4) := p;
 314
 315 testcase templateIntReverseOrderImported() runs on templateInt_mycomp {
 316   var template integer vtExpected := 4;
 317   if (log2str(tReverse2) == log2str(vtExpected)) {
 318     setverdict(pass);
 319   }
 320   else {
 321     setverdict(fail, "Expected: ", vtExpected, ", got: ", tReverse2);
 322   }
 323 }
 324
 325 // same as the previous test, but with a non-parameterized template
 326 template integer tReverse3 := tImported(tNonPard);
 327
 328 template integer tNonPard := (1, 2);
 329
 330 testcase templateIntReverseOrderImported2() runs on templateInt_mycomp {
 331   var template integer vtExpected := (1, 2);
 332   if (log2str(tReverse3) == log2str(vtExpected)) {
 333     setverdict(pass);
 334   }
 335   else {
 336     setverdict(fail, "Expected: ", vtExpected, ", got: ", tReverse3);
 337   }
 338 }
 339
 340 control {
 341  execute(templateIntSpec());
 342  execute(templateIntList());
 343  execute(templateIntComp());
 344  execute(templateIntOmit());
 345  execute(templateIntAny());
 346  execute(templateIntAnyorNone());
 347  execute(templateIntRange1());
 348  execute(templateIntRange2());
 349  execute(templateIntRange3());
 350  execute(templateIntRange4());
 351  execute(templateIntIfpresent());
 352  execute(TR_HJ94652());
 353  execute(templateIntSubtype());
 354  execute(templateIntReverseOrder());
 355  execute(templateIntReverseOrderImported());
 356  execute(templateIntReverseOrderImported2());
 357 }
 358 }