Sync with 5.4.0

[deliverable/titan.core.git] / regression_test / templateFloat / TtemplateFloat.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 TtemplateFloat {
type component templateFloat_mycomp {};
type record templateFloat_rec {
 float x1,
 float x2,
 float x3 optional };
template templateFloat_rec templateFloat_tSpec :={ //specific values
 x1:=1.1,
 x2:=2.1,
 x3:=3.1 };
template templateFloat_rec templateFloat_tList :={ //specific value and value list
 x1:=1.1,
 x2:=(2.1,3.1,6.1),
 x3:=3.1 };
template templateFloat_rec templateFloat_tComp :={ //specific value and compl. list
 x1:=1.1,
 x2:=complement (2.1,3.1,6.1),
 x3:=3.1 };
template templateFloat_rec templateFloat_tOmit :={ //omitting values
 x1:=1.1,
 x2:=2.1,
 x3:=omit } ;
template templateFloat_rec templateFloat_tAny :={ //specific and any value
 x1:=1.1,
 x2:=2.1,
 x3:=? } ;
template templateFloat_rec templateFloat_tAnyorNone :={ //specific and AnyorNone value
 x1:=1.1,
 x2:=2.1,
 x3:=* };
template templateFloat_rec templateFloat_tRange1 :={ //specific value and Range
 x1:=1.1,
 x2:=(2.1 ..4.1),
 x3:=3.1 };
template templateFloat_rec templateFloat_tRange2 :={ //specific value and Range
 x1:=1.1,
 x2:=(2.1 .. 4.1),
 x3:=3.1 };
template templateFloat_rec templateFloat_tRange3 :={ //specific value and Range
 x1:=1.1,
 x2:=(2.1 .. infinity),
 x3:=3.1 };
template templateFloat_rec templateFloat_tRange4 :={ //specific value and Range
 x1:=1.1,
 x2:=(-infinity .. 4.1),
 x3:=3.1 };
template templateFloat_rec templateFloat_tIfpresent :={ //specific value and ifpresent
 x1:=1.1,
 x2:=2.1,
 x3:=3.1 ifpresent };
 
template float templateFloat_tNaN := not_a_number;
template float templateFloat_tPosInf := infinity;
template float templateFloat_tNegInf := -infinity;

testcase templateFloatSpec() runs on templateFloat_mycomp {
var templateFloat_rec x1,x2;		//specific value
x1:={ x1:=1.1,  x2:=2.1,  x3:=3.1 };
x2:={ x1:=2.1,  x2:=2.1,  x3:=3.1 };
//match
if (match(x1,templateFloat_tSpec)) {setverdict(pass);}
 else {setverdict(fail);}
//no match
if (not(match(x2,templateFloat_tSpec))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateFloatList() runs on templateFloat_mycomp {
var templateFloat_rec x1,x2,x3;		//value list
x1:={ x1:=1.1,  x2:=6.1,  x3:=3.1 };
x2:={ x1:=1.1,  x2:=7.1,  x3:=3.1 };
x3:={ x1:=2.1,  x2:=6.1,  x3:=3.1 };
//match
if (match(x1,templateFloat_tList)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: out of list
if (not(match(x2,templateFloat_tList))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateFloat_tList))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateFloatComp() runs on templateFloat_mycomp {
var templateFloat_rec x1,x2,x3;		//complemented list
x1:={ x1:=1.1,  x2:=7.1,  x3:=3.1 };
x2:={ x1:=1.1,  x2:=6.1,  x3:=3.1 };
x3:={ x1:=2.1,  x2:=7.1,  x3:=3.1 };
//match
if (match(x1,templateFloat_tComp)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: in the list
if (not(match(x2,templateFloat_tComp))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateFloat_tComp))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateFloatOmit() runs on templateFloat_mycomp {
var templateFloat_rec x1,x2,x3;		//omitting value
x1:={ x1:=1.1,  x2:=2.1,  x3:=omit };
x2:={ x1:=1.1,  x2:=2.1,  x3:=3.1 };
x3:={ x1:=2.1,  x2:=2.1,  x3:=omit };
//match
if (match(x1,templateFloat_tOmit)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: not omitted
if (not(match(x2,templateFloat_tOmit))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateFloat_tOmit))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateFloatAny() runs on templateFloat_mycomp {
var templateFloat_rec x1,x2,x3;		//any value
x1:={ x1:=1.1,  x2:=2.1,  x3:=3.1 };
x2:={ x1:=1.1,  x2:=2.1,  x3:=omit };
x3:={ x1:=2.1,  x2:=2.1,  x3:=3.1 };
//match
if (match(x1,templateFloat_tAny)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: field omitted
if (not(match(x2,templateFloat_tAny))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateFloat_tAny))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateFloatAnyorNone() runs on templateFloat_mycomp {
var templateFloat_rec x1,x2,x3;		//AnyorNone value
x1:={ x1:=1.1,  x2:=2.1,  x3:=omit };
x2:={ x1:=1.1,  x2:=2.1,  x3:=3.1 };
x3:={ x1:=2.1,  x2:=2.1,  x3:=omit };
//match: omitted
if (match(x1,templateFloat_tAnyorNone)) {setverdict(pass);}
 else {setverdict(fail);}
//match: value
if (match(x2,templateFloat_tAnyorNone)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateFloat_tAnyorNone))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateFloatRange1() runs on templateFloat_mycomp {
var templateFloat_rec x1,x2,x3;		//Range ( .. )
x1:={ x1:=1.1,  x2:=2.1,  x3:=3.1 };
x2:={ x1:=1.1,  x2:=5.1,  x3:=3.1 };
x3:={ x1:=2.1,  x2:=2.1,  x3:=3.1 };
//match
if (match(x1,templateFloat_tRange1)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: out of range
if (not(match(x2,templateFloat_tRange1))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateFloat_tRange1))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateFloatRange2() runs on templateFloat_mycomp {
var templateFloat_rec x1,x2,x3;		//Range ( to )
x1:={ x1:=1.1,  x2:=2.1,  x3:=3.1 };
x2:={ x1:=1.1,  x2:=5.1,  x3:=3.1 };
x3:={ x1:=2.1,  x2:=2.1,  x3:=3.1 };
//match
if (match(x1,templateFloat_tRange2)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: out of range
if (not(match(x2,templateFloat_tRange2))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateFloat_tRange2))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateFloatRange3() runs on templateFloat_mycomp {
var templateFloat_rec x1,x2,x3;		//Range, with infinity
x1:={ x1:=1.1,  x2:=8.1,  x3:=3.1 };
x2:={ x1:=1.1,  x2:=-5.1,  x3:=3.1 };
x3:={ x1:=2.1,  x2:=2.1,  x3:=3.1 };
//match
if (match(x1,templateFloat_tRange3)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: out of range
if (not(match(x2,templateFloat_tRange3))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateFloat_tRange3))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateFloatRange4() runs on templateFloat_mycomp {
var templateFloat_rec x1,x2,x3;		//Range with - infinity
x1:={ x1:=1.1,  x2:=-2.1,  x3:=3.1 };
x2:={ x1:=1.1,  x2:=5.1,  x3:=3.1 };
x3:={ x1:=2.1,  x2:=2.1,  x3:=3.1 };
//match
if (match(x1,templateFloat_tRange4)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: out of range
if (not(match(x2,templateFloat_tRange4))) {setverdict(pass);}
 else {setverdict(fail);}
//no match: other field
if (not(match(x3,templateFloat_tRange4))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateFloatIfpresent() runs on templateFloat_mycomp {
var templateFloat_rec x1,x2,x3,x4;		//ifpresent
x1:={ x1:=1.1,  x2:=2.1,  x3:=3.1 };
x2:={ x1:=1.1,  x2:=2.1,  x3:=omit };
x3:={ x1:=1.1,  x2:=2.1,  x3:=4.1 };
x4:={ x1:=2.1,  x2:=2.1,  x3:=omit };
//match: present and match
if (match(x1,templateFloat_tIfpresent)) {setverdict(pass);}
 else {setverdict(fail);}
//match: not present
if (match(x2,templateFloat_tIfpresent)) {setverdict(pass);}
 else {setverdict(fail);}
//no match: present and not match
if (not(match(x3,templateFloat_tIfpresent))) {setverdict(pass);}
 else {setverdict(fail);}
////no match: other field
if (not(match(x4,templateFloat_tIfpresent))) {setverdict(pass);}
 else {setverdict(fail);}
}

testcase templateFloatSpecialValues() runs on templateFloat_mycomp {
  var float v_nan := not_a_number;
  var float v_pos_inf := infinity;
  var float v_neg_inf := -infinity;
  
  if (match(v_nan, templateFloat_tNaN)) { setverdict(pass); }
  else { setverdict(fail, "not_a_number should match itself"); }
  
  if (match(v_pos_inf, templateFloat_tPosInf)) { setverdict(pass); }
  else { setverdict(fail, "infinity should match itself"); }
  
  if (match(v_neg_inf, templateFloat_tNegInf)) { setverdict(pass); }
  else { setverdict(fail, "-infinity should match itself"); }
}

control {
 execute(templateFloatSpec());
 execute(templateFloatList());
 execute(templateFloatComp());
 execute(templateFloatOmit());
 execute(templateFloatAny());
 execute(templateFloatAnyorNone());
 execute(templateFloatRange1());
 execute(templateFloatRange2());
 execute(templateFloatRange3());
 execute(templateFloatRange4());
 execute(templateFloatIfpresent());
 execute(templateFloatSpecialValues());
}
}