Sync with 5.4.1

[deliverable/titan.core.git] / regression_test / templateInt / TtemplateInt.ttcn

/******************************************************************************
 * Copyright (c) 2000-2015 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
 ******************************************************************************/
module TtemplateInt {

import from ImportedTemplates all;

type component templateInt_mycomp {};
type record templateInt_rec {
 integer x1,
 integer x2,
 integer x3 optional };
type integer templateInt_subtype (0..1457664);
 
template templateInt_rec templateInt_tSpec :={ //specific values
 x1:=1,
 x2:=2,
 x3:=3 };
template templateInt_rec templateInt_tList :={ //specific value and value list
 x1:=1,
 x2:=(2,3,6),
 x3:=3 };
template templateInt_rec templateInt_tComp :={ //specific value and compl. list
 x1:=1,
 x2:=complement (2,3,6),
 x3:=3 };
template templateInt_rec templateInt_tOmit :={ //omitting values
 x1:=1,
 x2:=2,
 x3:=omit } ;
template templateInt_rec templateInt_tAny :={ //specific and any value
 x1:=1,
 x2:=2,
 x3:=? } ;
template templateInt_rec templateInt_tAnyorNone :={ //specific and AnyorNone value
 x1:=1,
 x2:=2,
 x3:=* };
template templateInt_rec templateInt_tRange1 :={ //specific value and Range
 x1:=1,
 x2:=(2 ..4),
 x3:=3 };
template templateInt_rec templateInt_tRange2 :={ //specific value and Range
 x1:=1,
 x2:=(2 .. 4),
 x3:=3 };
template templateInt_rec templateInt_tRange3 :={ //specific value and Range
 x1:=1,
 x2:=(2 .. infinity),
 x3:=3 };
template templateInt_rec templateInt_tRange4 :={ //specific value and Range
 x1:=1,
 x2:=(-infinity .. 4),
 x3:=3 };
template templateInt_rec templateInt_tIfpresent :={ //specific value and ifpresent
 x1:=1,
 x2:=2,
 x3:=3 ifpresent };

testcase templateIntSpec() runs on templateInt_mycomp {
var templateInt_rec x1,x2;		//specific value
x1:={ x1:=1,  x2:=2,  x3:=3 };
x2:={ x1:=2,  x2:=2,  x3:=3 };
//match
if (match(x1,templateInt_tSpec)) {setverdict(pass);}
 else {setverdict(fail);}
//no match
if (not(match(x2,templateInt_tSpec))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateIntList() runs on templateInt_mycomp {
var templateInt_rec x1,x2,x3;		//value list
x1:={ x1:=1,  x2:=6,  x3:=3 };
x2:={ x1:=1,  x2:=7,  x3:=3 };
x3:={ x1:=2,  x2:=6,  x3:=3 };
//match
if (match(x1,templateInt_tList)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: out of list
if (not(match(x2,templateInt_tList))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateInt_tList))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateIntComp() runs on templateInt_mycomp {
var templateInt_rec x1,x2,x3;		//complemented list
x1:={ x1:=1,  x2:=7,  x3:=3 };
x2:={ x1:=1,  x2:=6,  x3:=3 };
x3:={ x1:=2,  x2:=7,  x3:=3 };
//match
if (match(x1,templateInt_tComp)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: in the list
if (not(match(x2,templateInt_tComp))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateInt_tComp))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateIntOmit() runs on templateInt_mycomp {
var templateInt_rec x1,x2,x3;		//omitting value
x1:={ x1:=1,  x2:=2,  x3:=omit };
x2:={ x1:=1,  x2:=2,  x3:=3 };
x3:={ x1:=2,  x2:=2,  x3:=omit };
//match
if (match(x1,templateInt_tOmit)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: not omitted
if (not(match(x2,templateInt_tOmit))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateInt_tOmit))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateIntAny() runs on templateInt_mycomp {
var templateInt_rec x1,x2,x3;		//any value
x1:={ x1:=1,  x2:=2,  x3:=3 };
x2:={ x1:=1,  x2:=2,  x3:=omit };
x3:={ x1:=2,  x2:=2,  x3:=3 };
//match
if (match(x1,templateInt_tAny)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: field omitted
if (not(match(x2,templateInt_tAny))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateInt_tAny))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateIntAnyorNone() runs on templateInt_mycomp {
var templateInt_rec x1,x2,x3;		//AnyorNone value
x1:={ x1:=1,  x2:=2,  x3:=omit };
x2:={ x1:=1,  x2:=2,  x3:=3 };
x3:={ x1:=2,  x2:=2,  x3:=omit };
//match: omitted
if (match(x1,templateInt_tAnyorNone)) {setverdict(pass);}
 else {setverdict(fail);}
//match: value
if (match(x2,templateInt_tAnyorNone)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateInt_tAnyorNone))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateIntRange1() runs on templateInt_mycomp {
var templateInt_rec x1,x2,x3;		//Range (x .. y)
x1:={ x1:=1,  x2:=2,  x3:=3 };
x2:={ x1:=1,  x2:=5,  x3:=3 };
x3:={ x1:=2,  x2:=2,  x3:=3 };
//match
if (match(x1,templateInt_tRange1)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: out of range
if (not(match(x2,templateInt_tRange1))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateInt_tRange1))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateIntRange2() runs on templateInt_mycomp {
var templateInt_rec x1,x2,x3;		//Range (x to y)
x1:={ x1:=1,  x2:=2,  x3:=3 };
x2:={ x1:=1,  x2:=5,  x3:=3 };
x3:={ x1:=2,  x2:=2,  x3:=3 };
//match
if (match(x1,templateInt_tRange2)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: out of range
if (not(match(x2,templateInt_tRange2))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateInt_tRange2))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateIntRange3() runs on templateInt_mycomp {
var templateInt_rec x1,x2,x3;		//Range, with infinity
x1:={ x1:=1,  x2:=8,  x3:=3 };
x2:={ x1:=1,  x2:=-5,  x3:=3 };
x3:={ x1:=2,  x2:=2,  x3:=3 };
//match
if (match(x1,templateInt_tRange3)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: out of range
if (not(match(x2,templateInt_tRange3))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateInt_tRange3))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateIntRange4() runs on templateInt_mycomp {
var templateInt_rec x1,x2,x3;		//Range with - infinity
x1:={ x1:=1,  x2:=-2,  x3:=3 };
x2:={ x1:=1,  x2:=5,  x3:=3 };
x3:={ x1:=2,  x2:=2,  x3:=3 };
//match
if (match(x1,templateInt_tRange4)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: out of range
if (not(match(x2,templateInt_tRange4))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateInt_tRange4))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateIntIfpresent() runs on templateInt_mycomp {
var templateInt_rec x1,x2,x3,x4;		//ifpresent
x1:={ x1:=1,  x2:=2,  x3:=3 };
x2:={ x1:=1,  x2:=2,  x3:=omit };
x3:={ x1:=1,  x2:=2,  x3:=4 };
x4:={ x1:=2,  x2:=2,  x3:=omit };
//match: present and match
if (match(x1,templateInt_tIfpresent)) {setverdict(pass);}
 else {setverdict(fail);}
//match: not present
if (match(x2,templateInt_tIfpresent)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: present and not match
if (not(match(x3,templateInt_tIfpresent))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x4,templateInt_tIfpresent))) {setverdict(pass);}
 else {setverdict(fail);}
}

// Types for TR_HJ94652.
type record TR_HJ94652_myrec {
  integer myrecint
}

template TR_HJ94652_myrec TR_HJ94652_mytemp(integer myint) := {
  myrecint := (myint - 100 .. myint)
}

type record of TR_HJ94652_myrec TR_HJ94652_mylist

testcase TR_HJ94652() runs on templateInt_mycomp {
  // INTEGER_template::copy_template() was not implemented correctly for
  // VALUE_RANGE templates.
  var template TR_HJ94652_mylist myownlist := { }
  for (var integer i := 1; i <= 3; i := i + 1) {
    myownlist[i] := TR_HJ94652_mytemp(i * 100)
  }
  for (var integer i := 1; i <= 3; i := i + 1) {
    var charstring s1 := log2str(myownlist[i])
    var charstring s2 := log2str(TR_HJ94652_mytemp(i * 100))
    if (s1 == s2) { setverdict(pass) }
    else { setverdict(fail) }
  }
}

testcase templateIntSubtype() runs on templateInt_mycomp {
  // this tests the use of inline templates (value ranges)
  // with subtypes and variables
  var templateInt_subtype x := 312;
  var templateInt_subtype lower_limit := 100;
  var templateInt_subtype upper_limit := 65535;
  if (not match(x, templateInt_subtype:(0..upper_limit))) { // TR: artf602477
    setverdict(fail);
  }
  if (not match(x, integer:(100..upper_limit))) {
    setverdict(fail);
  }
  if (not match(312, templateInt_subtype:(100..upper_limit))) {
    setverdict(fail);
  }
  if (not match(x, templateInt_subtype:(100..65535))) {
    setverdict(fail);
  }
  if (not match(x, templateInt_subtype:(lower_limit..65535))) {
    setverdict(fail);
  }
  if (not match(x, templateInt_subtype:(lower_limit..upper_limit))) {
    setverdict(fail);
  }
  setverdict(pass);
}

// test case: using a parameterized template with no actual parameters (using default values)
// before its declaration
template integer tReverse := tPard;

template integer tPard(integer p := 6) := p;

testcase templateIntReverseOrder() runs on templateInt_mycomp {
  var template integer vtExpected := 6;
  if (log2str(tReverse) == log2str(vtExpected)) {
    setverdict(pass);
  }
  else {
    setverdict(fail, "Expected: ", vtExpected, ", got: ", tReverse);
  }
}

// same test, but the parameterized template is passed as a parameter to
// an imported parameterized template
template integer tReverse2 := tImported(tPard2);

template integer tPard2(integer p := 4) := p;

testcase templateIntReverseOrderImported() runs on templateInt_mycomp {
  var template integer vtExpected := 4;
  if (log2str(tReverse2) == log2str(vtExpected)) {
    setverdict(pass);
  }
  else {
    setverdict(fail, "Expected: ", vtExpected, ", got: ", tReverse2);
  }
}

// same as the previous test, but with a non-parameterized template
template integer tReverse3 := tImported(tNonPard);

template integer tNonPard := (1, 2);

testcase templateIntReverseOrderImported2() runs on templateInt_mycomp {
  var template integer vtExpected := (1, 2);
  if (log2str(tReverse3) == log2str(vtExpected)) {
    setverdict(pass);
  }
  else {
    setverdict(fail, "Expected: ", vtExpected, ", got: ", tReverse3);
  }
}

control {
 execute(templateIntSpec());
 execute(templateIntList());
 execute(templateIntComp());
 execute(templateIntOmit());
 execute(templateIntAny());
 execute(templateIntAnyorNone());
 execute(templateIntRange1());
 execute(templateIntRange2());
 execute(templateIntRange3());
 execute(templateIntRange4());
 execute(templateIntIfpresent());
 execute(TR_HJ94652());
 execute(templateIntSubtype());
 execute(templateIntReverseOrder());
 execute(templateIntReverseOrderImported());
 execute(templateIntReverseOrderImported2());
}
}