-
balaskoa authored
Signed-off-by:balaskoa <Jeno.Balasko@ericsson.com> Change-Id: I317823c4627aac382b4bfaf37ab6664cf5cbbab5
balaskoa authoredSigned-off-by:
Code owners
Assign users and groups as approvers for specific file changes. Learn more.
predefFunctTest.ttcn 131.46 KiB
/******************************************************************************
* Copyright (c) 2000-2019 Ericsson Telecom AB
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
*
* Contributors:
* Balasko, Jeno
*
******************************************************************************/
//These tests are supplementary testcases to ../predefFunction/*
//If commented testcases are commented back, the code can be used in static test, as well
module predefFunctTest {
const charstring c_cs_empty := ""
type record of bitstring RoBS;
type record of hexstring RoHS;
type record of octetstring RoOS;
type record of integer RoI;
type record of charstring RoCS;
type record of universal charstring RoUCS;
type set of integer SoI;
const bitstring c_bs_empty1 := ''B
const integer c_2e31 := 2147483648;
const integer c_2e32 := 4294967296;
const RoI c_roi_empty := {};
const RoI c_roi_1 := {-1}
const RoI c_roi_2 := {-2, -1}
const RoI c_roi3 := {-3,-2,-1}
type component CT{}
//====== str2float ==========
testcase tc_predef_str2float_empty() runs on CT {
var charstring vl_cs_empty := "";
@try {
var float f := str2float( vl_cs_empty & c_cs_empty);
setverdict(fail, "exception was expected")
} @catch(e) {
setverdict(pass, "exception catched")
}
}
testcase tc_predef_str2float_empty2() runs on CT {
var charstring vl_cs_empty := "";
@try {
var float f := str2float( vl_cs_empty);
setverdict(fail, "exception was expected")
} @catch(e) {
setverdict(pass, "exception catched")
}
}
type record of float RoF;
// good cases
testcase tc_predef_str2float_good1() runs on CT {
var RoCS vl_roc := {"1","-123", "-0.000","0.0","+0.0", "1.0", "002.34567890", "+003.000000", "+4.0","5.0e+0", "-6.0e+2", "7.125e+10", "8.250e+100","9e5" }
var RoF vl_expected := {1.0, -123.0, -0.0, 0.0, +0.0,1.0, 2.34567890, 3.0, 4.0, 5.0,-600.0, 71.25e+9, 8.25e100, 9e5 }
var integer N := sizeof( vl_roc );
for(var integer i:=0;i<N; i:=i+1) {
if(str2float(vl_roc[i])==vl_expected[i]) {
// setverdict(pass);
log(i);
} else {
setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",str2float(vl_roc[i]));
}
}
setverdict(pass);
}
testcase tc_predef_str2float_good2() runs on CT {
var charstring vl_cs := "infinity";
if(str2float(vl_cs) == infinity){
setverdict(pass)
} else {
setverdict(fail);
}
}
testcase tc_predef_str2float_good2a() runs on CT {
var charstring vl_cs := "infinity";
if (infinity == str2float(vl_cs)) {
setverdict(pass)
} else {
setverdict(fail);
}
}
//compile time evaluation
testcase tc_predef_str2float_good2b() runs on CT {
if(str2float("infinity") == infinity){
setverdict(pass)
} else {
setverdict(fail);
}
}
testcase tc_predef_str2float_good2c() runs on CT {
if(infinity == str2float("infinity")){
setverdict(pass)
} else {
setverdict(fail);
}
}
testcase tc_predef_str2float_good2d() runs on CT {
var charstring vl_cs := "INF";
@try {
if(str2float(vl_cs) == infinity){
setverdict(fail, "DTE expected")
} else {
setverdict(fail,"DTE expected");
}
} @catch(e) {
setverdict(pass,"DTE catched")
}
}
//compile time evaluation - semantic error
//testcase tc_predef_str2float_good2d() runs on CT {
// if(str2float("INF") == infinity){
// setverdict(pass)
// } else {
// setverdict(fail);
// }
//}
testcase tc_predef_str2float_good3() runs on CT {
var charstring vl_cs := "-infinity";
if(str2float(vl_cs) == -infinity){
setverdict(pass)
} else {
setverdict(fail);
}
}
testcase tc_predef_str2float_good3b() runs on CT {
if(str2float("-infinity") == -infinity){
setverdict(pass)
} else {
setverdict(fail);
}
}
//Status:fails on cpp, pass on java
testcase tc_predef_str2float_good4() runs on CT {
var charstring vl_cs := "not_a_number";
if(str2float(vl_cs) == not_a_number){
setverdict(pass)
} else {
setverdict(fail,"expected not_a_number got:", str2float(vl_cs));
}
}
//Status:pass on cpp, pass on java
testcase tc_predef_str2float_good4b() runs on CT {
if(str2float("not_a_number") == not_a_number){
setverdict(pass)
} else {
setverdict(fail);
}
}
testcase tc_predef_str2float_good4c() runs on CT {
var charstring vl_cs := "NaN";
@try {
if(str2float(vl_cs) == not_a_number){
setverdict(fail)
} else {
setverdict(fail);
}
} @catch(e) {
setverdict(pass,"DTE catched")
}
}
testcase tc_predef_str2float_good5() runs on CT {
var charstring vl_cs := "not_a_number";
if( not_a_number == str2float(vl_cs) ){
setverdict(pass)
} else {
setverdict(fail,"expected not_a_number got:", str2float(vl_cs));
}
}
//semantic error
//testcase tc_predef_str2float_good4d() runs on CT {
// if(str2float("NaN") == not_a_number){
// setverdict(pass)
// } else {
// setverdict(fail);
// }
//}
testcase tc_predef_str2float_bad1() runs on CT {
var charstring vl_cs := ".3";
@try {
var float f := str2float( vl_cs );
setverdict(fail, "exception was expected but got:",f)
} @catch(e) {
setverdict(pass, "exception catched")
}
}
//testcase tc_predef_str2float_bad1b() runs on CT {
// @try {
// var float f := str2float(".3");//semantic error
// setverdict(fail, "exception was expected but got:" , f )
//
// } @catch(e) {
// setverdict(pass, "exception catched")
// }
//}
testcase tc_predef_str2float_bad2() runs on CT {
var charstring vl_cs := "1.2f3";
@try {
var float f := str2float( vl_cs & c_cs_empty);
setverdict(fail, "exception was expected")
} @catch(e) {
setverdict(pass, "exception catched")
}
}
//testcase tc_predef_str2float_bad2b() runs on CT {
// @try {
// var float f := str2float( "1.2f3"); //semantic error
// setverdict(fail, "exception was expected")
//
// } @catch(e) {
// setverdict(pass, "exception catched")
// }
//}
testcase tc_predef_str2float_bad3() runs on CT {
var charstring vl_cs := "DADDY1.23";
@try {
var float f := str2float( vl_cs & c_cs_empty);
setverdict(fail, "exception was expected")
} @catch(e) {
setverdict(pass, "exception catched")
}
}
testcase tc_predef_str2float_bad4() runs on CT {
var charstring vl_cs := "1.23e23d";
@try {
var float f := str2float( vl_cs & c_cs_empty);
setverdict(fail, "exception was expected")
} @catch(e) {
setverdict(pass, "exception catched")
}
}
//=========== rnd ======================
testcase tc_predef_rnd() runs on CT {
var float vl_f := rnd();
var float vl_seed :=3.45e+2;
for(var integer i:=0; i<10;i:=i+1){
vl_f := rnd();
if( 0.0 <= vl_f and vl_f< 1.0) {
log(vl_f)
} else {
setverdict(fail, vl_f);
}
vl_f := rnd(vl_seed);
if( 0.0 <= vl_f and vl_f< 1.0) {
log(vl_f)
} else {
setverdict(fail, vl_f);
}
setverdict(pass);
}
}
//====== bit2hex ===============
testcase tc_predef_bit2hex1() runs on CT {
var RoBS bs_list := {
'0000'B, '0001'B, '0010'B, '0011'B,
'0100'B, '0101'B, '0110'B, '0111'B,
'1000'B, '1001'B, '1010'B, '1011'B,
'1100'B, '1101'B, '1110'B, '1111'B
}
var RoHS hs_list := {
'0'H, '1'H, '2'H, '3'H,
'4'H, '5'H, '6'H, '7'H,
'8'H, '9'H, 'A'H, 'B'H,
'C'H, 'D'H, 'E'H, 'F'H
}
var integer N := lengthof(bs_list);
for (var integer i:=0; i<N; i:=i+1){
if(bit2hex(bs_list[i])==hs_list[i]) {
setverdict(pass,bs_list[i],"->",bit2hex(bs_list[i])," exp:", hs_list[i]);
} else {
setverdict(fail,bs_list[i],"->",bit2hex(bs_list[i])," exp:", hs_list[i]);
}
}
}
//longer:
testcase tc_predef_bit2hex2() runs on CT {
var bitstring vl_bs1 := '0001'B, vl_bs2 :='0010'B,vl_bsF := '1111'B,vl_bsA:= '1010'B;
var hexstring vl_hs := bit2hex( vl_bs1 & vl_bs2 & vl_bsF & vl_bsA);
if (vl_hs == '12FA'H) {
setverdict(pass)
} else {
setverdict(fail, "expected '12FA'H got:", vl_hs);
}
}
//bitstring element is the argument
testcase tc_predef_bit2hex_bitstr_element() runs on CT {
var bitstring vl_bs := '001'B;
var RoHS exp := {'0'H,'0'H,'1'H};
for( var integer i:=0; i< lengthof(vl_bs); i:=i+1) {
if( bit2hex(vl_bs[i]) == exp[i]){
setverdict(pass,vl_bs[i],"->",bit2hex(vl_bs[i])," exp:", exp[i])
} else {
setverdict(fail)
}
}
}
//==== bit2oct ====
testcase tc_predef_bit2oct1() runs on CT {
var RoBS bs_list := {
'0000'B, '0001'B, '0010'B, '0011'B,
'0100'B, '0101'B, '0110'B, '0111'B,
'1000'B, '1001'B, '1010'B, '1011'B,
'1100'B, '1101'B, '1110'B, '1111'B
}
var RoOS os_list := {
'00'O, '01'O, '02'O, '03'O,
'04'O, '05'O, '06'O, '07'O,
'08'O, '09'O, '0A'O, '0B'O,
'0C'O, '0D'O, '0E'O, '0F'O
}
var integer N := lengthof(bs_list);
for (var integer i:=0; i<N; i:=i+1){
if(bit2oct(bs_list[i])==os_list[i]) {
setverdict(pass,bs_list[i],"->",bit2oct(bs_list[i])," exp:", os_list[i]);
} else {
setverdict(fail,bs_list[i],"->",bit2oct(bs_list[i])," exp:", os_list[i]);
}
}
}
testcase tc_predef_bit2oct2() runs on CT {
var bitstring vl_bs1 := '0001'B, vl_bs2 :='0010'B,vl_bsF := '1111'B,vl_bsA:= '1010'B;
var octetstring vl_os := bit2oct( vl_bs1 & vl_bs2 & vl_bsF & vl_bsA);
if (vl_os == '12FA'O) {
setverdict(pass)
} else {
setverdict(fail, "expected '12FA'O got:", vl_os);
}
}
//bitstring element is the argument
testcase tc_predef_bit2oct_bitstr_element() runs on CT {
var bitstring vl_bs := '001'B;
var RoOS exp := {'00'O,'00'O,'01'O};
for( var integer i:=0; i< lengthof(vl_bs); i:=i+1) {
if( bit2oct(vl_bs[i]) == exp[i]){
setverdict(pass,vl_bs[i],"->",bit2oct(vl_bs[i])," exp:", exp[i])
} else {
setverdict(fail)
}
}
}
//====== bit2int ===============
testcase tc_predef_bit2int_good() runs on CT {
var RoBS vl_bslist := {'0'B, '00000'B, '1'B, '0001'B,'000000000001'B,'0010'B, '0011'B,'0100'B,'0101'B,
'0110'B,'0111'B,'1000'B,'00001000'B,'1001'B,'1010'B, '10000'B, '10001'B
}
var RoI vl_expectedList := {0,0,1,1,1,2,3,4,5,6,7,8,8,9,10,16,17}
var integer N := sizeof(vl_bslist);
for(var integer i:=0;i<N; i:=i+1){
if(bit2int(vl_bslist[i])!=vl_expectedList[i]){
setverdict(fail, "expected:", vl_expectedList[i]," got:", bit2int(vl_bslist[i]));
}
}
setverdict(pass);
}
testcase tc_predef_bit2int_good_with_space() runs on CT {
var bitstring vl_bs := '1 0000'B
if (bit2int(vl_bs)!=16 ){
setverdict(fail, "expected: 16 got:", bit2int('1 0000'B) );
}
setverdict(pass);
}
testcase tc_predef_bit2int_good_long1() runs on CT {
var bitstring vl_bs := '1 0000 0000 0000 0000'B
if (bit2int('1 0000 0000 0000 0000'B)!=65536 ){
setverdict(fail, "expected: 65536 got:", bit2int('1 0000 0000 0000 0000'B) );
}
setverdict(pass);
}
testcase tc_predef_bit2int_good_long2() runs on CT {
var bitstring vl_bs := '1 0000 0000 0000 0000'B
if (bit2int(vl_bs)!=65536 ){
setverdict(fail, "expected: 65536 got:", bit2int(vl_bs) );
}
setverdict(pass);
}
testcase tc_predef_bit2int_good_long3() runs on CT {
var bitstring vl_bs := '1 0000 1000 0010 0001'B
if (bit2int(vl_bs)!=67617 ){
setverdict(fail, "expected: 67617 got:", bit2int(vl_bs) );
}
setverdict(pass);
}
testcase tc_predef_bit2int_good_long4() runs on CT {
var bitstring vl_bs := '10 0000 1000 0010 0001'B
if (bit2int(vl_bs)!=133153 ){
setverdict(fail, "expected: 133153 got:", bit2int(vl_bs) );
}
setverdict(pass,"expected: 133153 got:", bit2int(vl_bs));
}
//longer than 32 bits:
testcase tc_predef_bit2int_good_long5() runs on CT {
var bitstring vl_bs := '0001 0000 0000 0000 0000 0000 0000 0000 0001'B;
var integer expected := 4294967297;
if (bit2int(vl_bs)!=expected ){
setverdict(fail, "expected:", expected, " got:", bit2int(vl_bs) );
} else {
setverdict(pass,"expected:", expected," got:", bit2int(vl_bs));
}
}
//bitstring element is the argument
testcase tc_predef_bit2int_bitstr_element() runs on CT {
var bitstring vl_bs := '001'B;
var RoI exp := {0,0,1};
for( var integer i:=0; i< lengthof(vl_bs); i:=i+1) {
if( bit2int(vl_bs[i]) == exp[i]){
setverdict(pass,vl_bs[i],"->",bit2int(vl_bs[i])," exp:", exp[i])
} else {
setverdict(fail)
}
}
}
//Eclipse Titan handles only space as whitespace
//testcase tc_predef_bit2int_good_with_whitespace() runs on CT {
// if (bit2int('1 100000'B)!=16 ){
// setverdict(fail, "expected: 16 got:", bit2int('1 0000'B) );
// }
// setverdict(pass);
//}
testcase tc_predef_bit2int_good_empty() runs on CT {
var bitstring vl_bs :=''B
if (bit2int(vl_bs)!=0 ){ //??????
setverdict(fail, "expected: 0 got:", bit2int(''B) );
}
setverdict(pass);
}
//===== bit2oct =====
//C.1.15 Bitstring to octetstring
//bit2oct('111010111'B)= '01D7'O
testcase tc_predef_bit2oct_good() runs on CT {
var RoBS vl_bslist := {'0'B, '00000'B, '1'B, '0001'B,'0000 0000 0001'B,'0010'B, '0011'B,'0100'B,'0101'B,
'0110'B,'0111'B,'1000'B,'00001000'B,'1001'B,'1010'B, '10000'B, '10001'B
}
var RoOS vl_expectedList := {'00'O,'00'O,'01'O,'01'O,'0001'O,'02'O,'03'O,'04'O,'05'O,
'06'O,'07'O,'08'O,'08'O,'09'O,'0A'O,'10'O,'11'O}
var integer N := sizeof(vl_bslist);
for(var integer i:=0;i<N; i:=i+1){
if(bit2oct(vl_bslist[i])!=vl_expectedList[i]){
setverdict(fail, "expected (i=",i,") ", vl_expectedList[i]," got:", bit2oct(vl_bslist[i]));
}
}
setverdict(pass);
}
testcase tc_predef_bit2oct_good_with_space() runs on CT {
var bitstring vl_bs := '10000'B;
if (bit2oct(vl_bs)!='10'O ){
setverdict(fail, "expected: '10'O got:", bit2oct('10000'B) );
}
setverdict(pass);
}
//===== bit2str =====
testcase tc_predef_bit2str_good() runs on CT {
var RoBS vl_bslist := {'0'B, '00000'B, '1'B, '0001'B,'000000000001'B,'0010'B, '0011'B,'0100'B,'0101'B,
'0110'B,'0111'B,'1000'B,'00001000'B,'1001'B,'1010'B, '10000'B, '10001'B
}
var RoCS vl_expectedList := {"0", "00000", "1", "0001","000000000001","0010", "0011","0100","0101",
"0110","0111","1000","00001000","1001","1010", "10000", "10001"
}
var integer N := sizeof(vl_bslist);
for(var integer i:=0;i<N; i:=i+1){
if(bit2str(vl_bslist[i])!=vl_expectedList[i]){
setverdict(fail, "expected (i=",i,") ", vl_expectedList[i]," got:", bit2str(vl_bslist[i]));
}
}
setverdict(pass);
}
testcase tc_predef_bit2str_good_with_space() runs on CT {
var bitstring vl_bs := '1 0000'B
if (bit2str(vl_bs)!="10000" ){
setverdict(fail, "expected: \"1 0000\" got:", bit2str('1 0000'B) );
}
setverdict(pass);
}
testcase tc_predef_bit2str_good_empty() runs on CT {
var bitstring vl_bs := ''B
if (bit2str(vl_bs)!="" ){
setverdict(fail, "expected: \"\" got:", bit2str(''B) );
}
setverdict(pass);
}
//bitstring element is the argument
testcase tc_predef_bit2str_bitstr_element() runs on CT {
var bitstring vl_bs := '001'B;
var RoCS exp := {"0","0","1"};
for( var integer i:=0; i< lengthof(vl_bs); i:=i+1) {
if( bit2str(vl_bs[i]) == exp[i]){
setverdict(pass,vl_bs[i],"->",bit2str(vl_bs[i])," exp:", exp[i])
} else {
setverdict(fail)
}
}
}
//char2int
testcase tc_predef_char2int_good() runs on CT {
var RoCS vl_cslist := { "a","b", "z", "A","Z", "0","1", "9"," ","!", "\"","~","\n","\b","\t", "\f","\r" }
var RoI vl_expectedList := { 97, 98, 122, 65, 90, 48,49,57, 32, 33, 34,126,10,8,9,12,13}
var integer N := sizeof(vl_cslist);
for(var integer i:=0;i<N; i:=i+1){
if(char2int(vl_cslist[i])!=vl_expectedList[i]){
setverdict(fail, "expected (i=",i,") ", vl_expectedList[i]," got:", char2int(vl_cslist[i]));
}
}
setverdict(pass);
}
testcase tc_predef_char2int_good_charstring_element() runs on CT {
var charstring cs := "Apple ABBA78-~";
var RoI exp := {65,112,112,108,101, 32, 65,66,66,65, 55,56,45,126}
for( var integer i:=0; i< lengthof(cs); i:=i+1) {
if (char2int(cs[i])==exp[i]) {
setverdict(pass, cs[i],"->",char2int(cs[i])," expected: ",exp[i]);
} else{
setverdict(fail, cs[i],"->",char2int(cs[i])," expected: ",exp[i]);
}
}
}
testcase tc_predef_char2int_bad1() runs on CT {
var charstring vl_cs := "aa";
@try {
var integer vl_i :=char2int(vl_cs);
setverdict(fail, "Not expected to reach this line, DTE expected")
} @catch(e){
setverdict(pass, "DTE catched")
}
}
testcase tc_predef_char2int_bad2() runs on CT {
var charstring vl_cs := ""
@try {
var integer vl_i :=char2int(vl_cs);
setverdict(fail, "Not expected to reach this line, DTE expected")
} @catch(e){
setverdict(pass, "DTE catched")
}
}
testcase tc_predef_char2int_bad3() runs on CT {
var charstring vl_cs := "á";//UTF-8
@try {
var integer vl_i :=char2int(vl_cs);
setverdict(fail, "Not expected to reach this line, DTE expected")
} @catch(e){
setverdict(pass, "DTE catched")
}
}
testcase tc_predef_char2int_bad4() runs on CT {
var charstring vl_cs := "á";//UTF-8
@try {
var integer vl_i :=char2int(vl_cs[0]);
setverdict(fail, "Not expected to reach this line, DTE expected")
} @catch(e){
setverdict(pass, "DTE catched")
}
}
//====== char2oct =====
//C.1.11 Character to octetstring
//char2oct ("Tinky-Winky") = '54696E6B792D57696E6B79'O
testcase tc_predef_char2oct_good1() runs on CT {
var RoCS vl_cslist := {"a","b", "z", "A","Z", "0","1", "9"," ","!", "\"", "\\","~" }
var RoOS vl_expectedList := { '61'O,'62'O,'7A'O, '41'O, '5A'O,'30'O,'31'O,'39'O,'20'O,'21'O, '22'O, '5C'O,'7E'O }
var integer N := sizeof(vl_cslist);
for(var integer i:=0;i<N; i:=i+1){
if(char2oct(vl_cslist[i])!=vl_expectedList[i]){
setverdict(fail, "expected (i=",i,") ", vl_expectedList[i]," got:", char2oct(vl_cslist[i]));
}
}
setverdict(pass);
}
testcase tc_predef_char2oct_charstring_element() runs on CT {
var charstring vl_cslist := "abzAZ019 !\"\\~\b\t\n\f\r\'\"*?"
var octetstring vl_expectedList := '61627A415A3031392021225C7E08090A0C0D27222A3F'O
var integer N := lengthof(vl_cslist);
for(var integer i:=0;i<N; i:=i+1){
if(char2oct(vl_cslist[i])!=vl_expectedList[i]){
setverdict(fail, "expected (i=",i,") ", vl_expectedList[i]," got:", char2oct(vl_cslist[i]));
}
}
setverdict(pass);
}
testcase tc_predef_char2oct_good_empty() runs on CT {
var charstring vl_cs := "";
if (char2oct(vl_cs)!=''O ){
setverdict(fail, "expected: \'\'O got:", char2oct("") );
}
setverdict(pass);
}
//char2hexdigit ??
//====== float2int ======
testcase tc_predef_float2int_good1() runs on CT {
// var RoC vl_roc := {"1","-123", "-0.000","0.0","+0.0", "1.0", "002.34567890", "+003.000000", "+4.0","5.0e+0", "-6.0e+2", "7.125e+10", "8.250e+100","9e5" }
var RoF vl_rof := {1.0, -123.0, -0.0, 0.0, +0.0,1.0, 2.34567890, 3.0, 4.0, 5.0,-600.0, 71.25e+9, 429496729.6e+1, 9e5, -0.1}
var RoI vl_expected := {1,-123,0,0,0,1,2,3,4,5,-600, 71250000000, 4294967296,900000, 0}
var integer N := sizeof( vl_rof );
for(var integer i:=0;i<N; i:=i+1) {
if(float2int(vl_rof[i])!=vl_expected[i]) {
setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",float2int(vl_rof[i]));
}
}
setverdict(pass);
}
testcase tc_predef_float2int_bad1() runs on CT {
var float f := infinity;
@try{
var integer i := float2int(f);
setverdict(fail,"This line should not be reached");
} @catch(e){
setverdict(pass, "Expected DTE: ",e);
}
}
//======= float2str ==============
testcase tc_predef_float2str_good0() runs on CT {
// var RoC vl_roc := {"1","-123", "-0.000","0.0","+0.0", "1.0", "002.34567890", "+003.000000", "+4.0","5.0e+0", "-6.0e+2", "7.125e+10", "8.250e+100","9e5" }
var RoF vl_rof := {1.0, -123.0, -0.0, 0.0, +0.0,1.0, 2.34567890, 3.0, 4.0, 5.0,-600.0, 71.25e+9, 429496729.6e+1, 9e5, -0.1}
var RoCS vl_expected := {"1.000000","-123.000000","-0.000000"}
var integer N := 2; //sizeof( vl_rof );
for(var integer i:=0;i<N; i:=i+1) {
if(float2str(vl_rof[i])!=vl_expected[i]) {
setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",float2str(vl_rof[i]), ", log2str:", vl_rof[i]);
}
}
setverdict(pass);
}
//First case
// -MAX_DECIMAL_FLOAT<f && f<=-MIN_DECIMAL_FLOAT
//|| (MIN_DECIMAL_FLOAT<=f && MAX_DECIMAL_FLOAT)
// ( Not scientific notation: )
testcase tc_predef_float2str_good1() runs on CT{
var float f := -0.99e+10;
var charstring expected := "-9900000000.000000"; // -9 900 000 000
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))} else {setverdict(fail,"Expected:",expected," got: ", log2str(f))}
}
testcase tc_predef_float2str_good2() runs on CT{
var float f := 0.99e+10 ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
var charstring expected := "9900000000.000000"; // -9 900 000 000
log(f);
if(float2str(f)==expected) {
setverdict(pass,"Expected:",expected," got: ", float2str(f), " log2str:", f)
} else {
setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
}
testcase tc_predef_float2str_good3() runs on CT{
var float f := -0.0001 ;
var charstring expected := "-0.000100";
log(f);
var charstring logged := float2str(f);
if(logged==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))} else {setverdict(fail,"Expected:",expected," got: ", logged)}
}
testcase tc_predef_float2str_good4() runs on CT{
var float f := 0.0001 ;
var charstring expected := "0.000100";
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
}
testcase tc_predef_float2str_good5() runs on CT{
var float f := -1000.0 ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
var charstring expected := "-1000.000000";
// var charstring result := float2str(f);
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
}
testcase tc_predef_float2str_good6() runs on CT{
var float f := 1000.0 ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
var charstring expected := "1000.000000";
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
}
testcase tc_predef_float2str_good7() runs on CT{
var float f := 0.0 ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
var charstring expected := "0.000000";
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
}
//2nd case:
testcase tc_predef_float2str_good8() runs on CT{
var float f := infinity ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
var charstring expected := "infinity";
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
}
//3rd case:
testcase tc_predef_float2str_good9() runs on CT{
var float f := -infinity ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
var charstring expected := "-infinity";
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
}
//4th case not a number
testcase tc_predef_float2str_good10() runs on CT{
var float f := not_a_number ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
var charstring expected := "not_a_number";
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
}
//5th case: Scientific notation
//too small or too big absolut value
testcase tc_predef_float2str_good11() runs on CT{
var float f := -1.0e-5 ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
var charstring expected := "-1.000000e-05";
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
}
testcase tc_predef_float2str_good12() runs on CT{
var float f := 1.0e-5 ; //f<MIN_DEC_FLOAT
var charstring expected := "1.000000e-05";
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
}
testcase tc_predef_float2str_good13() runs on CT{
var float f := 0.000099 ;
var charstring expected := "9.900000e-05";
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
}
testcase tc_predef_float2str_good14() runs on CT{
var float f := -0.000099;
var charstring expected := "-9.900000e-05";
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
else {setverdict(fail,"Expected:",expected," got: ", float2str(f), "log2str:", f)}
}
//Status: fails on cpp
testcase tc_predef_float2str_good15() runs on CT{
var float f := 9.987654e+5;
var charstring expected := "998765.400000";
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
else {setverdict(fail,"Expected:",expected," got: ", float2str(f), "log2str:", f)}
}
testcase tc_predef_float2str_good16() runs on CT{
var float f := 9.987654e-5;
var charstring expected := "9.987654e-05";
log(f);
if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
else {setverdict(fail,"Expected:",expected," got: ", float2str(f), "log2str:", f)}
}
//hex2bit
testcase tc_predef_hex2bit_empty1() runs on CT {
if(hex2bit(''H)==''B){
setverdict(pass);
} else {
setverdict(fail);
}
}
testcase tc_predef_hex2bit_empty2() runs on CT {
var hexstring vl_hs :=''H
if(hex2bit(vl_hs)==''B){
setverdict(pass);
} else {
setverdict(fail);
}
}
testcase tc_predef_hex2bit_unbound() runs on CT {
var hexstring vl_hs;
@try {
if(hex2bit(vl_hs)==''B){
setverdict(fail,"DTE expected");
} else {
setverdict(fail,"DTE expected");
}
}@catch(e){
setverdict(pass, "Expected DTE catched")
}
}
//testcase tc_predef_hex2bit_good1() runs on CT {
// var hexstring vl_hs :='FE'H
// if(hex2bit(vl_hs)=='11111111'B){
// setverdict(pass);
// } else {
// setverdict(fail);
// }
//}
testcase tc_predef_hex2bit_good1() runs on CT {
var RoHS vl_hexaValues := {
'0'H,'1'H,'2'H,'3'H,'4'H,
'5'H,'6'H,'7'H,'8'H,'9'H,
'A'H,'B'H,'C'H,'D'H,'E'H,'F'H
}
var RoBS vl_expectedValues := {
'0000'B,'0001'B,'0010'B,'0011'B,'0100'B,
'0101'B,'0110'B,'0111'B,'1000'B,'1001'B,
'1010'B,'1011'B,'1100'B,'1101'B,'1110'B,'1111'B
}
var integer N := sizeof(vl_hexaValues);
for(var integer i:=0;i<N;i:=i+1){
if(hex2bit(vl_hexaValues[i])==vl_expectedValues[i]){
setverdict(pass);
} else {
setverdict(fail);
}
//log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2bit(vl_hexaValues[i]))
}
}
testcase tc_predef_hex2bit_good2() runs on CT{
var RoHS vl_hexaValues := {'01'H,'0A'H,'FF'H}
var RoBS vl_expectedValues := {'00000001'B,'0000 1010'B,'11111111'B}
var integer N := sizeof(vl_hexaValues);
for(var integer i:=0;i<N;i:=i+1){
if(hex2bit(vl_hexaValues[i])==vl_expectedValues[i]){
setverdict(pass);
} else {
setverdict(fail);
}
log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2bit(vl_hexaValues[i]))
}
}
testcase tc_predef_hex2bit_good20() runs on CT {
var hexstring vl_hs :='ABBA9'H
if(hex2bit(vl_hs)=='10101011101110101001'B){
setverdict(pass);
} else {
setverdict(fail);
}
}
//hexstring element in the arg
testcase tc_predef_hex2bit_hexstr_element() runs on CT {
var hexstring vl_hs :='ABBA9'H
var bitstring vl_bs := '10101011101110101001'B
var integer N := lengthof(vl_hs);
for(var integer i:=0;i<N;i:=i+1){
if(hex2bit(vl_hs[i])==substr(vl_bs,i*4,4)){
setverdict(pass);
} else {
setverdict(fail);
}
log(vl_hs[i],"->",hex2bit(vl_hs[i])," expected: ",substr(vl_bs,i*4,4));
}
}
//===== hex2int ====
testcase tc_predef_hex2int_unbound() runs on CT {
var hexstring vl_hs;
@try {
if(hex2int(vl_hs)==0){
setverdict(fail,"DTE expected");
} else {
setverdict(fail,"DTE expected");
}
}@catch(e){
setverdict(pass, "Expected DTE catched")
}
}
testcase tc_predef_hex2int_empty() runs on CT {
var hexstring vl_hs:=''H;
if(hex2int(vl_hs)==0){
setverdict(pass);
} else {
setverdict(fail);
}
}
testcase tc_predef_hex2int_good1() runs on CT {
var RoHS vl_hexaValues := {
'0'H,'1'H,'2'H,'3'H,'4'H,
'5'H,'6'H,'7'H,'8'H,'9'H,
'A'H,'B'H,'C'H,'D'H,'E'H,'F'H
}
var RoI vl_expectedValues := {
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
}
var integer N := sizeof(vl_hexaValues);
for(var integer i:=0;i<N;i:=i+1){
if(hex2int(vl_hexaValues[i])==vl_expectedValues[i]){
setverdict(pass);
} else {
setverdict(fail);
}
log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2int(vl_hexaValues[i]))
}
}
testcase tc_predef_hex2int_good2() runs on CT{
var RoHS vl_hexaValues := {'01'H,'0A'H,'FF'H,'ABBA9'H}
var RoI vl_expectedValues := {1,10,255,703401}
var integer N := sizeof(vl_hexaValues);
for(var integer i:=0;i<N;i:=i+1){
if(hex2int(vl_hexaValues[i])==vl_expectedValues[i]){
setverdict(pass);
} else {
setverdict(fail);
}
log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2int(vl_hexaValues[i]))
}
}
testcase tc_predef_hex2int_good3() runs on CT {
var hexstring vl_hs :='0123456789ABCDEF'H
if(hex2int(vl_hs)==81985529216486895){
setverdict(pass);
} else {
setverdict(fail);
}
}
//hexstring element in the arg
testcase tc_predef_hex2int_hexstr_element() runs on CT {
var hexstring vl_hs :='019ABBAF'H
var RoI int_list :={0,1,9,10,11,11,10,15}
var integer N := lengthof(vl_hs);
for(var integer i:=0;i<N;i:=i+1){
if (hex2int(vl_hs[i])==int_list[i]) {
setverdict(pass);
} else {
setverdict(fail);
}
log(vl_hs[i],"->",hex2bit(vl_hs[i])," expected: ",int_list[i]);
}
}
//===== hex2oct =====
testcase tc_predef_hex2oct_empty1() runs on CT {
if(hex2oct(''H)==''O) {
setverdict(pass);
} else {
setverdict(fail);
}
}
testcase tc_predef_hex2oct_empty2() runs on CT {
var hexstring vl_hs :=''H
if(hex2oct(vl_hs)==''O){
setverdict(pass);
} else {
setverdict(fail);
}
}
testcase tc_predef_hex2oct_unbound() runs on CT {
var hexstring vl_hs;
@try {
if(hex2oct(vl_hs)==''O){
setverdict(fail,"DTE expected");
} else {
setverdict(fail,"DTE expected");
}
}@catch(e){
setverdict(pass, "Expected DTE catched")
}
}
testcase tc_predef_hex2oct_good1() runs on CT {
var RoHS vl_hexaValues := {
'0'H,'1'H,'2'H,'3'H,'4'H,
'5'H,'6'H,'7'H,'8'H,'9'H,
'A'H,'B'H,'C'H,'D'H,'E'H,'F'H
}
var RoOS vl_expectedValues := {
'00'O,'01'O,'02'O,'03'O,'04'O,
'05'O,'06'O,'07'O,'08'O,'09'O,
'0A'O,'0B'O,'0C'O,'0D'O,'0E'O,'0F'O
}
var integer N := sizeof(vl_hexaValues);
for(var integer i:=0;i<N;i:=i+1){
if(hex2oct(vl_hexaValues[i])==vl_expectedValues[i]){
setverdict(pass);
} else {
setverdict(fail);
}
log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2oct(vl_hexaValues[i]))
}
}
testcase tc_predef_hex2oct_good2() runs on CT{
var RoHS vl_hexaValues := {'01'H,'0A'H,'EF'H, 'FF'H}
var RoOS vl_expectedValues := {'01'O,'0A'O, 'EF'O, 'FF'O}
var integer N := sizeof(vl_hexaValues);
for(var integer i:=0;i<N;i:=i+1){
if(hex2oct(vl_hexaValues[i])==vl_expectedValues[i]){
setverdict(pass);
} else {
setverdict(fail);
}
log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2oct(vl_hexaValues[i]))
}
}
//literal 1
testcase tc_predef_hex2oct_good3() runs on CT{
if(hex2oct('4'H)=='04'O){
setverdict(pass);
} else {
setverdict(fail);
}
}
//literal 2
testcase tc_predef_hex2oct_good4() runs on CT{
if(hex2oct('00FF'H)=='00FF'O){
setverdict(pass);
} else {
setverdict(fail);
}
}
//literal 3
testcase tc_predef_hex2oct_good5() runs on CT{
if(hex2oct('0FF'H)=='00FF'O){
setverdict(pass);
} else {
setverdict(fail);
}
}
//padding expected, runtime
testcase tc_predef_hex2oct_good6() runs on CT{
var hexstring vl_hs := '0FF'H
if(hex2oct(vl_hs)=='00FF'O){
setverdict(pass);
} else {
setverdict(fail);
}
}
testcase tc_predef_hex2oct_good7() runs on CT {
var hexstring vl_hs :='ABBA9'H
if(hex2oct(vl_hs)=='0ABBA9'O){
setverdict(pass);
} else {
setverdict(fail);
}
}
//hexstring element in the arg
testcase tc_predef_hex2oct_hexstr_element() runs on CT {
var hexstring vl_hs :='ABBA9'H
var RoOS vl_bs := { '0A'O,'0B'O,'0B'O,'0A'O,'09'O}
var integer N := lengthof(vl_hs);
for(var integer i:=0;i<N;i:=i+1){
if(hex2oct(vl_hs[i])==vl_bs[i]){
setverdict(pass);
} else {
setverdict(fail);
}
log(vl_hs[i],"->",hex2oct(vl_hs[i])," expected: ",vl_bs[i]);
}
}
//=========hex2str=============
//C.1.20 Hexstring to charstring
//Example: hex2str('AB801'H) // will return "AB801"
testcase tc_predef_hex2str_empty1() runs on CT {
var hexstring vl_hs :=''H
if(hex2str(vl_hs)==""){
setverdict(pass);
} else {
setverdict(fail);
}
}
testcase tc_predef_hex2str_unbound() runs on CT {
var hexstring vl_hs;
@try {
if(hex2str(vl_hs)==""){
setverdict(fail,"DTE expected");
} else {
setverdict(fail,"DTE expected");
}
setverdict(fail, "This line should not be reached");
}@catch(e){
setverdict(pass, "Expected DTE catched")
}
}
testcase tc_predef_hex2str_good1() runs on CT {
var RoHS vl_hexaValues := {
'0'H,'1'H,'2'H,'3'H,'4'H,
'5'H,'6'H,'7'H,'8'H,'9'H,
'A'H,'B'H,'C'H,'D'H,'E'H,'F'H
}
var RoCS vl_expectedValues := {
"0","1","2","3","4",
"5","6","7","8","9",
"A","B","C","D","E","F"
}
var integer N := sizeof(vl_hexaValues);
for(var integer i:=0;i<N;i:=i+1){
if(hex2str(vl_hexaValues[i])==vl_expectedValues[i]){
setverdict(pass);
} else {
setverdict(fail);
}
log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2str(vl_hexaValues[i]))
}
}
testcase tc_predef_hex2str_good2() runs on CT{
var RoHS vl_hexaValues := {'01'H,'0A'H,'EF'H, 'FF'H}
var RoCS vl_expectedValues := {"01","0A", "EF", "FF"}
var integer N := sizeof(vl_hexaValues);
for(var integer i:=0;i<N;i:=i+1){
if(hex2str(vl_hexaValues[i])==vl_expectedValues[i]){
setverdict(pass);
} else {
setverdict(fail);
}
log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2str(vl_hexaValues[i]))
}
}
//literal 1 (compiler time evaluation)
testcase tc_predef_hex2str_good3() runs on CT{
if(hex2str('4'H)=="4"){
setverdict(pass);
} else {
setverdict(fail);
}
}
//literal 2
testcase tc_predef_hex2str_good4() runs on CT{
if(hex2str('00FF'H)=="00FF"){
setverdict(pass);
} else {
setverdict(fail);
}
}
testcase tc_predef_hex2str_good5() runs on CT{
if(hex2str('0FF'H)=="0FF"){
setverdict(pass);
} else {
setverdict(fail);
}
}
//no padding
testcase tc_predef_hex2str_good6() runs on CT{
var hexstring vl_hs := '0FF'H
if(hex2str(vl_hs)=="0FF"){
setverdict(pass);
} else {
setverdict(fail);
}
}
//longer
testcase tc_predef_hex2str_good7() runs on CT {
var hexstring vl_hs :='0123456789ABBAF'H
if(hex2str(vl_hs)=="0123456789ABBAF"){
setverdict(pass);
} else {
setverdict(fail);
}
log(vl_hs,"->",hex2str(vl_hs))
}
//hexstring element
testcase tc_predef_hex2str_hexstring_element() runs on CT {
var hexstring vl_hs :='ABBA9'H
var RoCS vl_bs := { "A","B","B","A","9"}
var integer N := lengthof(vl_hs);
for(var integer i:=0;i<N;i:=i+1){
if(hex2str(vl_hs[i])==vl_bs[i]){
setverdict(pass);
} else {
setverdict(fail);
}
log(vl_hs[i],"->",hex2str(vl_hs[i])," expected: ",vl_bs[i]);
}
}
//int2bit
testcase tc_predef_int2bit_unbound() runs on CT {
var integer vl_i;
@try {
var bitstring vl_bs := int2bit(vl_i,2);
setverdict(fail, "DTE expected");
} @catch(e){
setverdict(pass,"DTE catched");
}
}
testcase tc_predef_int2bit_wrongLength() runs on CT {
var integer vl_i:= 4;
@try {
var bitstring vl_bs := int2bit(vl_i,2);
setverdict(fail, "DTE expected:");
} @catch(e){
setverdict(pass,"DTE catched");
}
}
testcase tc_predef_int2bit_negLength() runs on CT {
var integer vl_i:= -1;
@try {
var bitstring vl_bs := int2bit(vl_i,2);
setverdict(fail, "DTE expected:");
} @catch(e){
setverdict(pass,"DTE catched");
}
}
testcase tc_predef_int2bit_good1() runs on CT {
var RoBS vl_expectedList := {'00000'B, '00001'B,'00010'B, '00011'B,'00100'B,'00101'B,
'00110'B,'00111'B,'01000'B,'01001'B,'01010'B, '10000'B, '10001'B
}
var RoI vl_intList := {0,1,2,3,4,5,6,7,8,9,10,16,17}
var integer N := sizeof(vl_intList);
for(var integer i:=0;i<N; i:=i+1){
if(int2bit(vl_intList[i],5) != vl_expectedList[i]){
setverdict(fail, "expected:", vl_expectedList[i]," got:", int2bit(vl_intList[i],5) );
}
}
setverdict(pass);
}
testcase tc_predef_int2bit_good2() runs on CT {
var RoBS vl_expectedList := {'011111111'B,'100000000'B
}
var RoI vl_intList := {255,256}
var integer N := sizeof(vl_intList);
for(var integer i:=0;i<N; i:=i+1){
if(int2bit(vl_intList[i],9) != vl_expectedList[i]){
setverdict(fail, "expected:", vl_expectedList[i]," got:", int2bit(vl_intList[i],9) );
}
}
setverdict(pass);
}
testcase tc_predef_int2bit_good3() runs on CT {
var RoBS vl_expectedList := {'0111111110000'B,'1000000000000'B
}
var RoI vl_intList := {255*16,256*16}
var integer N := sizeof(vl_intList);
for(var integer i:=0;i<N; i:=i+1){
if(int2bit(vl_intList[i],9+4) != vl_expectedList[i]){
setverdict(fail, "expected:", vl_expectedList[i]," got:", int2bit(vl_intList[i],9+4) );
}
}
setverdict(pass);
}
//==== int2char ======
testcase tc_predef_int2char_good() runs on CT {
var RoCS vl_cslist := { "a","b", "z", "A","Z", "0","1", "9"," ","!", "\"","~","\n","\b","\t","\f","\r"}
var RoI vl_intList := { 97, 98, 122, 65, 90, 48,49,57, 32, 33, 34,126,10,8,9,12,13}
var integer N := sizeof(vl_cslist);
for(var integer i:=0;i<N; i:=i+1){
if(int2char(vl_intList[i])!=vl_cslist[i]){
setverdict(fail, "expected (i=",i,") ", vl_cslist[i]," got:", int2char(vl_intList[i]));
}
// log("expected (i=",i,") ", vl_cslist[i]," got:", int2char(vl_intList[i]))
}
setverdict(pass);
}
testcase tc_predef_int2char_list() runs on CT {
var charstring vl_c :="";
for(var integer i:=0;i<128; i:=i+1){
vl_c := int2char(i);
// log(int2char(i));
}
setverdict(pass);
}
testcase tc_predef_int2char_bad1() runs on CT {
var integer i := 128;
@try {
var charstring vl_cs := int2char(i)
setverdict(fail, "Not expected to reach this line, DTE expected")
} @catch(e){
setverdict(pass, "DTE catched")
}
}
testcase tc_predef_int2char_bad2() runs on CT {
var integer i := -1;
@try {
var charstring vl_cs := int2char(i)
setverdict(fail, "Not expected to reach this line, DTE expected")
} @catch(e){
setverdict(pass, "DTE catched")
}
}
//===int2enum===
//see: enumOper
//==== int2float =====
testcase tc_predef_int2float_good1() runs on CT {
var RoI vl_intlist := {1,-123,0,1,2,3,4,5,-600, 71250000000, 4294967296,9000000, 123000000000000000 }
var RoF vl_floatlist :={1.0,-123.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, -600.0, 7.125e+10, 4294967296.0, 9000000.0, 1.23e+17}
var integer N := sizeof( vl_intlist );
for(var integer i:=0;i<N; i:=i+1) {
if(int2float(vl_intlist[i])!=vl_floatlist[i]){
setverdict(fail);
}
// log((int2float(vl_intlist[i])));
}
setverdict(pass);
}
testcase tc_predef_int2float_good2() runs on CT {
const integer c_10e12 := 1000*1000*1000*1000;
var RoI vl_intlist := {c_10e12, c_10e12*c_10e12, c_10e12*c_10e12*c_10e12}
var RoF vl_floatlist :={ 1.0e+12, 1e24,1.0e36}
var integer N := sizeof( vl_intlist );
for(var integer i:=0;i<N; i:=i+1) {
if(int2float(vl_intlist[i])!=vl_floatlist[i]){
setverdict(fail);
}
// log((int2float(vl_intlist[i])));
}
setverdict(pass);
}
//==== int2hex ====
testcase tc_predef_int2hex_good1() runs on CT {
var RoI vl_intlist := {0,1,123, 600, 703401 }
var RoHS vl_hexlist :={'00000'H,'00001'H,'0007B'H,'00258'H, 'ABBA9'H}
var integer N := sizeof( vl_intlist );
for(var integer i:=0;i<N; i:=i+1) {
if(int2hex(vl_intlist[i],5)!=vl_hexlist[i]){
setverdict(fail);
}
// log((int2hex(vl_intlist[i],5)));
}
setverdict(pass);
}
testcase tc_predef_int2hex_bad1() runs on CT {
var integer i := -1;
@try {
var hexstring vl_cs := int2hex(i,2)
setverdict(fail, "Not expected to reach this line, DTE expected")
} @catch(e){
setverdict(pass, "DTE catched")
}
}
testcase tc_predef_int2hex_bad2() runs on CT {
var integer i := 600;
@try {
var hexstring vl_cs := int2hex(i,2)
setverdict(fail, "Not expected to reach this line, DTE expected")
} @catch(e){
setverdict(pass, "DTE catched")
}
}
testcase tc_predef_int2hex_bad3() runs on CT {
var integer i := 703401;
@try {
var hexstring vl_cs := int2hex(i,4)
setverdict(fail, "Not expected to reach this line, DTE expected")
} @catch(e){
setverdict(pass, "DTE catched")
}
}
//int2oct
testcase tc_predef_int2oct_good1() runs on CT {
var RoI vl_intlist := {0,1,123, 600, 703401 }
var RoOS vl_octlist :={'000000'O,'000001'O,'00007B'O,'000258'O, '0ABBA9'O }
var integer N := sizeof( vl_intlist );
for(var integer i:=0;i<N; i:=i+1) {
if(int2oct(vl_intlist[i],3)!=vl_octlist[i]){
setverdict(fail);
}
// log((int2oct(vl_intlist[i],3)));
}
setverdict(pass);
}
testcase tc_predef_int2oct_good1a() runs on CT {
var RoI vl_intlist := {2147483648,2147483648*256,2147483648*256*2}
var RoI vl_lenlist := {4,5,6}
var RoOS vl_octlist := {'8000 0000'O,'80 0000 0000'O,'010000000000'O}
var integer N := sizeof( vl_intlist );
for(var integer i:=0;i<N; i:=i+1) {
if(int2oct(vl_intlist[i],vl_lenlist[i])!=vl_octlist[i]){
setverdict(fail, "expected: ", vl_octlist[i]," got: ",int2oct(vl_intlist[i],vl_lenlist[i]));
}
// log((int2oct(vl_intlist[i],4)));
}
setverdict(pass);
}
testcase tc_predef_int2oct_good2() runs on CT {
var RoI vl_intlist := {0,c_2e31/8,c_2e31/2,c_2e31 /*first BigInteger - ok*/,
1*c_2e32-1,1*c_2e32,123*c_2e32, 600*c_2e32, 703401*c_2e32 }
var RoOS vl_octlist :={
'000000000000000000000000000000'O,
'000000000000000000000010000000'O,
'000000000000000000000040000000'O,
'000000000000000000000080000000'O,
'0000000000000000000000FFFFFFFF'O,
'000000000000000000000100000000'O,
'000000000000000000007B00000000'O,
'000000000000000000025800000000'O,
'00000000000000000ABBA900000000'O
}
var integer N := sizeof( vl_intlist );
for(var integer i:=0;i<N; i:=i+1) {
if(int2oct(vl_intlist[i],3+12)!=vl_octlist[i]){
setverdict(fail,"expected: ", vl_octlist[i]," got: ",int2oct(vl_intlist[i],3+12));
}
// log((int2oct(vl_intlist[i],3+12)));
}
setverdict(pass);
}
testcase tc_predef_int2oct_good3() runs on CT {
var RoI vl_intlist := {0,1*c_2e32,123*c_2e32, 600*c_2e32, 703401*c_2e32 }
var RoOS vl_octlist :={
'00000000000000'O,
'00000100000000'O,
'00007B00000000'O,
'00025800000000'O,
'0ABBA900000000'O
}
var integer N := sizeof( vl_intlist );
for(var integer i:=0;i<N; i:=i+1) {
if(int2oct(vl_intlist[i],3+4)!=vl_octlist[i]){
setverdict(fail,"expected: ", vl_octlist[i]," got: ",int2oct(vl_intlist[i],3+4));
}
// log((int2oct(vl_intlist[i],3+4)));
}
setverdict(pass);
}
testcase tc_predef_int2oct_bad1() runs on CT {
var integer i := -1;
@try {
var octetstring vl_cs := int2oct(i,2)
setverdict(fail, "Not expected to reach this line, DTE expected")
} @catch(e){
setverdict(pass, "DTE catched")
}
}
testcase tc_predef_int2oct_bad2() runs on CT {
var integer i := 600;
@try {
var octetstring vl_cs := int2oct(i,1)
setverdict(fail, "Not expected to reach this line, DTE expected")
} @catch(e){
setverdict(pass, "DTE catched")
}
}
testcase tc_predef_int2oct_bad3() runs on CT {
var integer i := 703401;
@try {
var octetstring vl_cs := int2oct(i,2)
setverdict(fail, "Not expected to reach this line, DTE expected")
} @catch(e){
setverdict(pass, "DTE catched")
}
}
testcase tc_predef_int2oct_bad4() runs on CT {
var integer i := 2147483648;
@try {
var octetstring vl_cs := int2oct(i,3)
setverdict(fail, "Not expected to reach this line, DTE expected")
} @catch(e){
setverdict(pass, "DTE catched")
}
}
//int2str
testcase tc_predef_int2str_good1() runs on CT {
var RoI vl_intlist := {0,1,123, 600, 703401,-703401}
var RoCS vl_strlist :={"0","1","123","600","703401","-703401"}
var integer N := sizeof( vl_intlist );
for(var integer i:=0;i<N; i:=i+1) {
if(int2str(vl_intlist[i])!=vl_strlist[i]){
setverdict(fail);
}
// log((int2str(vl_intlist[i])));
}
setverdict(pass);
}
testcase tc_predef_int2str_good2() runs on CT {
var RoI vl_intlist := {0,c_2e31/8,c_2e31/2,c_2e31 /*first BigInteger - ok*/,
1*c_2e32-1,1*c_2e32,123*c_2e32, 600*c_2e32, 703401*c_2e32 }
var RoCS vl_strlist :={
"0",
"268435456",
"1073741824",
"2147483648",
"4294967295",
"4294967296",
"528280977408",
"2576980377600",
"3021084290973696"
}
var integer N := sizeof( vl_intlist );
for(var integer i:=0;i<N; i:=i+1) {
if(int2str(vl_intlist[i])!=vl_strlist[i]){
setverdict(fail,"expected: ", vl_strlist[i]," got: ",int2str(vl_intlist[i]));
}
// log((int2str(vl_intlist[i])));
}
setverdict(pass);
}
//int2unichar
testcase tc_predef_int2unichar_good1() runs on CT {
var RoI vl_intlist := {0,1,123, 600, 703401}
var RoUCS vl_strlist :={char(0,0,0,0),char(0,0,0,1),"{",char(0,0,2,88),char(0,10,187,169)}
var integer N := sizeof( vl_intlist );
for(var integer i:=0;i<N; i:=i+1) {
if(int2unichar(vl_intlist[i])!=vl_strlist[i]){
setverdict(fail,i);
}
// log((int2unichar(vl_intlist[i])));
}
setverdict(pass);
}
testcase tc_predef_int2unichar_good2() runs on CT {
var RoI vl_intlist := {0,c_2e31/8,c_2e31/2, c_2e31-1}
var RoUCS vl_strlist :={
char(0, 0, 0, 0),
char(16, 0, 0, 0),
char(64, 0, 0, 0),
char(127,255,255,255)
}
var integer N := sizeof( vl_intlist );
for(var integer i:=0;i<N; i:=i+1) {
if(int2unichar(vl_intlist[i])!=vl_strlist[i]){
setverdict(fail,"expected: ", vl_strlist[i]," got: ",int2unichar(vl_intlist[i]));
}
// log((int2unichar(vl_intlist[i])));
}
setverdict(pass);
}
testcase tc_predef_int2unichar_bad1() runs on CT {
var integer vl_i := -1;
var universal charstring vl_cs;
@try {
vl_cs := int2unichar(vl_i);
setverdict(fail, "exception was expected but got:",vl_cs)
} @catch(e) {
setverdict(pass, "exception catched")
}
}
testcase tc_predef_int2unichar_bad2() runs on CT {
var integer vl_i := c_2e31 /*first BigInteger - ok*/;
var universal charstring vl_cs;
@try {
vl_cs := int2unichar(vl_i);
setverdict(fail, "exception was expected but got:",vl_cs)
} @catch(e) {
setverdict(pass, "exception catched")
}
}
testcase tc_predef_int2unichar_bad3() runs on CT {
var integer vl_i := 703401*c_2e32;
var universal charstring vl_cs;
@try {
vl_cs := int2unichar(vl_i);
setverdict(fail, "exception was expected but got:",vl_cs)
} @catch(e) {
setverdict(pass, "exception catched")
}
}
//===== oct2bit =====
testcase tc_predef_oct2bit_good() runs on CT {
var RoBS vl_bslist := {
'00000000'B, '0000 0001'B,'0000 0000 0000 0001'B,'0000 0010'B, '0000 0011'B,
'0000 0100'B,'0000 0101'B,'0000 0110'B,'0000 0111'B,'0000 1000'B,
'0000 1001'B,'0000 1010'B, '0001 0000'B, '0001 0001'B, '0000 0000 0000 0000 0001 0001'B,
'1010 1011 1100 1101 1110 1111'B
}
var RoOS vl_oslist := {
'00'O,'01'O,'0001'O,'02'O,'03'O,
'04'O,'05'O,'06'O,'07'O,'08'O,
'09'O,'0A'O,'10'O,'11'O,'00 00 11'O,
'AB CD EF'O
}
var integer N := sizeof(vl_oslist);
for(var integer i:=0;i<N; i:=i+1){
if(oct2bit(vl_oslist[i])!=vl_bslist[i]){
setverdict(fail, "expected (i=",i,") ", vl_bslist[i]," got:", oct2bit(vl_oslist[i]));
}
log(oct2bit(vl_oslist[i]))
}
setverdict(pass);
}
//===== oct2char =======
//1. "The input parameter invalue shall not contain octet values higher than 7F."
//2. "The resulting charstring shall have the same length as the input octetstring."
testcase tc_predef_oct2char_good1() runs on CT {
var charstring cs := "Dipsy";
var octetstring os := '4469707379'O;
if( oct2char(os) == cs) {
setverdict(pass)
} else {
setverdict(fail);
}
log(oct2char(os), " Dipsy");
var RoOS vl_oslist := { '44'O,'61'O,'62'O,'7A'O, '41'O, '5A'O,'30'O,'31'O,'39'O,'20'O,'21'O, '22'O, '5C'O,'7E'O }
var RoCS vl_cslist := {"D","a","b", "z", "A","Z", "0","1", "9"," ","!", "\"", "\\","~" }
var integer N := sizeof(vl_oslist);
for(var integer i:=0;i<N; i:=i+1){
if(oct2char(vl_oslist[i])!=vl_cslist[i]){
setverdict(fail, "expected (i=",i,") ", vl_cslist[i]," got:", oct2char(vl_oslist[i]));
} else {
setverdict(pass);
}
log(oct2char(vl_oslist[i]))
}
setverdict(pass);
}
testcase tc_predef_oct2char_good2() runs on CT {
var RoOS vl_oslist := {
'00'O,'01'O,'02'O,'03'O,
'04'O,'05'O,'06'O,'07'O,'08'O,
'09'O,'0A'O,'0b'O,'0C'O, '0d'O,'0e'O,'0f'O,
'10'O, '11'O,'12'O,'13'O
}
var integer N := sizeof(vl_oslist);
for(var integer i:=0;i<N; i:=i+1){
if(oct2char(vl_oslist[i])!= int2char(i)) {
setverdict(fail, "expected (i=",i,") ",int2char(i)," got:", oct2char(vl_oslist[i]));
}
// log(oct2char(vl_oslist[i]))
}
setverdict(pass);
}
testcase tc_predef_oct2char_bad1() runs on CT {
var charstring vl_cs;
var octetstring vl_os := '80'O;
@try {
vl_cs := oct2char(vl_os);
setverdict(fail, "exception was expected but got:",vl_cs)
} @catch(e) {
setverdict(pass, "exception catched")
}
}
testcase tc_predef_oct2char_bad2() runs on CT {
var charstring vl_cs;
var octetstring vl_os := 'AF'O;
@try {
vl_cs := oct2char(vl_os);
setverdict(fail, "exception was expected but got:",vl_cs)
} @catch(e) {
setverdict(pass, "exception catched")
}
}
testcase tc_predef_oct2char_bad3() runs on CT {
var charstring vl_cs;
var octetstring vl_os := 'FF'O;
@try {
vl_cs := oct2char(vl_os);
setverdict(fail, "exception was expected but got:",vl_cs)
} @catch(e) {
setverdict(pass, "exception catched")
}
}
//octetstring element is the argument
testcase tc_predef_oct2char_octetstr_elem() runs on CT {
var charstring cs := "Dipsy";
var octetstring os := '4469707379'O;
var integer N := lengthof(os);
for( var integer i:=0;i<N;i:=i+1){
if (oct2char(os[i]) == cs[i]) {
setverdict(pass, os[i],"->",oct2char(os[i])," expected: ", cs[i] )
} else {
setverdict(fail, os[i],"->",oct2char(os[i])," expected: ", cs[i] )
}
}
}
//octetstring element is the argument
testcase tc_predef_oct2char_octetstr_elem_bad() runs on CT {
var charstring cs := "Áá";
var octetstring os := 'C1E1'O; //>'7f'O 2x
var integer N := lengthof(os);
for( var integer i:=0;i<N;i:=i+1){
@try {
if (oct2char(os[i]) == cs[i]) {
log( os[i],"->",oct2char(os[i])," expected: ", cs[i] );
} else {
log( os[i],"-->",oct2char(os[i])," expected: ", cs[i] );
}
setverdict(fail, "This line should not be reached");
}@catch(e){
setverdict(pass, "Expected DTE: ", e);
}
}
}
//===== oct2hex ======
testcase tc_predef_oct2hex_good1() runs on CT {
var RoOS vl_oslist := {
'00'O,'01'O,'0001'O,'02'O,'03'O,
'04'O,'05'O,'06'O,'07'O,'08'O,
'08'O,'09'O,'0A'O,'10'O,'11'O,
'00 00 11'O,'1A'O,'7F'O, '30 31 32 33 39 3A 3B 7e 60'O, 'ABBA'O, ''O
}
var RoHS vl_cslist := {
'00'H,'01'H,'0001'H,'02'H,'03'H,
'04'H,'05'H,'06'H,'07'H,'08'H,
'08'H,'09'H,'0A'H,'10'H,'11'H,
'00 00 11'H,'1A'H,'7F'H, '30 31 32 33 39 3A 3B 7e 60'H,'ABBA'H,''H
}
var integer N := sizeof(vl_oslist);
for(var integer i:=0;i<N; i:=i+1){
if(oct2hex(vl_oslist[i])!=vl_cslist[i]){
setverdict(fail, "expected (i=",i,") ", vl_cslist[i]," got:", oct2hex(vl_oslist[i]));
}
// log(oct2hex(vl_oslist[i]))
}
setverdict(pass);
}
//oct2int
testcase tc_predef_oct2int_good1() runs on CT {
var RoOS vl_oslist := {
'00'O,'01'O,'0001'O,'02'O,'03'O,
'04'O,'05'O,'06'O,'07'O,'08'O,
'09'O,'0A'O,'10'O,'11'O,
'00 00 11'O,'1A'O,'7F'O,'ABBA'O, 'FFFF FFFF'O, '01 0000 0000'O
}
var RoI vl_intlist := {
0,1,1,2,3,4,5,6,7,8,9,
10,16,17,17,26,127,43962, 4294967295, 4294967296
}
var integer N := sizeof(vl_oslist);
for(var integer i:=0;i<N; i:=i+1){
if(oct2int(vl_oslist[i])!=vl_intlist[i]){
setverdict(fail, "expected (i=",i,") ", vl_intlist[i]," got:", oct2int(vl_oslist[i]));
}
// log(oct2int(vl_oslist[i]))
}
setverdict(pass);
}
testcase tc_predef_oct2int_good1a() runs on CT {
var octetstring vl_os := '30 31 32 33 39 3A 3B 7e 60'O;
var integer vl_i := 888988667715635609184;
if(oct2int(vl_os) != vl_i) {
setverdict(fail,"expected:", vl_i, " got: ", oct2int(vl_os));
} else {
setverdict(pass);
}
}
testcase tc_predef_oct2int_good1b() runs on CT {
var octetstring vl_os := '10 0000 0000 0000 0000'O;
var integer vl_i := 16*65536*65536*65536*65536;
if(oct2int(vl_os) != vl_i) {
setverdict(fail,"expected:", vl_i, " got: ", oct2int(vl_os));
} else {
setverdict(pass,"expected:", vl_i, " got: ", oct2int(vl_os));
}
}
testcase tc_predef_oct2int_good2() runs on CT {
const RoOS vl_oslist := {
'00'O,'01'O,'0001'O,'02'O,'03'O,
'04'O,'05'O,'06'O,'07'O,'08'O,
'09'O,'0A'O,'10'O,'11'O,
'00 00 11'O,'1A'O,'7F'O, '30 31 32 33 39 3A 3B 7e 60'O, 'ABBA'O
}
var RoI vl_intlist := {
0,1,1,2,3,4,5,6,7,8,9,
10,16,17,17,26,127,888988667715635609184,43962
}
var integer N := sizeof(vl_oslist);
for(var integer i:=0;i<N; i:=i+1){
if(oct2int(vl_oslist[i])!=vl_intlist[i]){
setverdict(fail, "expected (i=",i,") ", vl_intlist[i]," got:", oct2int(vl_oslist[i]));
}
// log(oct2int(vl_oslist[i]))
}
setverdict(pass);
}
testcase tc_predef_oct2int_empty() runs on CT {
var integer vl_i;
var octetstring vl_os := ''O;
if (oct2int(vl_os)!= 0) {
setverdict(fail,"expected 0")
} else {
setverdict(pass)
}
}
//oct2str
//C.1.24 Octetstring to character string
//oct2str('4469707379'O) = "4469707379"
testcase tc_predef_oct2str_good1() runs on CT {
var RoOS vl_oslist := {
'00'O,'01'O,'0001'O,'02'O,'03'O,
'04'O,'05'O,'06'O,'07'O,'08'O,
'08'O,'09'O,'0A'O,'10'O,'11'O,
'00 00 11'O,'1A'O,'7F'O, '30 31 32 33 39 3A 3B 7e 60'O, 'ABBA'O, ''O
}
var RoCS vl_cslist := {
"00","01","0001","02","03",
"04","05","06","07","08",
"08","09","0A","10","11",
"000011","1A","7F", "30313233393A3B7E60","ABBA",""
}
var integer N := sizeof(vl_oslist);
for(var integer i:=0;i<N; i:=i+1){
if(oct2str(vl_oslist[i])!=vl_cslist[i]){
setverdict(fail, "expected (i=",i,") ", vl_cslist[i]," got:", oct2str(vl_oslist[i]));
}
// log(oct2str(vl_oslist[i]))
}
setverdict(pass);
}
testcase tc_predef_oct2str_good2() runs on CT {
const RoOS vl_oslist := {
'00'O,'01'O,'0001'O,'02'O,'03'O,
'04'O,'05'O,'06'O,'07'O,'08'O,
'08'O,'09'O,'0A'O,'10'O,'11'O,
'00 00 11'O,'1A'O,'7F'O, '30 31 32 33 39 3A 3B 7e 60'O, 'ABBA'O, ''O
}
var RoCS vl_cslist := {
"00","01","0001","02","03",
"04","05","06","07","08",
"08","09","0A","10","11",
"000011","1A","7F", "30313233393A3B7E60","ABBA",""
}
var integer N := sizeof(vl_oslist);
for(var integer i:=0;i<N; i:=i+1){
if(oct2str(vl_oslist[i])!=vl_cslist[i]){
setverdict(fail, "expected (i=",i,") ", vl_cslist[i]," got:", oct2str(vl_oslist[i]));
}
// log(oct2str(vl_oslist[i]))
}
setverdict(pass);
}
//for octetstring elements
testcase tc_predef_oct2str_octetstring_element() runs on CT {
var octetstring vl_os :='ABBA09'O
var RoCS vl_cs := { "AB","BA","09"}
var integer N := lengthof(vl_os);
for(var integer i:=0;i<N;i:=i+1){
if(oct2str(vl_os[i])==vl_cs[i]){
setverdict(pass);
} else {
setverdict(fail);
}
log(vl_os[i],"->",oct2str(vl_os[i])," expected: ",vl_cs[i]);
}
}
//==== universal charstring related functions: see ucharstrOper ===
//================================================
//============ replace() =========================
//================================================
//*********** Replace() for bitstring ************
// remove 2 chars from the beginnining, compile time
testcase tc_predef_replace_bitstring_1() runs on CT {
var bitstring vl_bs := replace('0000 1111'B,0,2,''B);
if(vl_bs != '00 1111'B){
setverdict(fail, "expected '001111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
//var pars
testcase tc_predef_replace_bitstring_1a() runs on CT {
var integer vl_beginning :=0, vl_len := 2;
var bitstring vl_bs := replace('0000 1111'B,vl_beginning,vl_len,''B);
if(vl_bs != '00 1111'B){
setverdict(fail, "expected '001111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
//const pars
testcase tc_predef_replace_bitstring_1b() runs on CT {
const integer vl_beginning :=0, vl_len := 2;
var bitstring vl_bs := replace('0000 1111'B,vl_beginning,vl_len,''B);
if(vl_bs != '00 1111'B){
setverdict(fail, "expected '001111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining, run time
testcase tc_predef_replace_bitstring_2() runs on CT {
var bitstring vl_bs0 := '0000 1111'B
var bitstring vl_bs := replace(vl_bs0,0,2,''B);
if(vl_bs != '00 1111'B){
setverdict(fail, "expected '001111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining, run time
//parameters are variables
testcase tc_predef_replace_bitstring_2a() runs on CT {
var integer vl_beginning :=0, vl_len := 2;
var bitstring vl_bs0 := '0000 1111'B
var bitstring vl_bs := replace(vl_bs0,vl_beginning,vl_len,''B);
if(vl_bs != '00 1111'B){
setverdict(fail, "expected '001111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 1 char compile time
testcase tc_predef_replace_bitstring_3() runs on CT {
var bitstring vl_bs := replace('0000 1111'B,0,2,'1'B);
if(vl_bs != '100 1111'B){
setverdict(fail, "expected '1001111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 1 char runtime
testcase tc_predef_replace_bitstring_4() runs on CT {
var bitstring vl_bs0 := '0000 1111'B
var bitstring vl_bs := replace(vl_bs0,0,2,'1'B);
if(vl_bs != '100 1111'B){
setverdict(fail, "expected '1001111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 2 char compile time
testcase tc_predef_replace_bitstring_5() runs on CT {
var bitstring vl_bs := replace('0000 1111'B,0,2,'11'B);
if(vl_bs != '1100 1111'B){
setverdict(fail, "expected '11001111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 2 char runtime
testcase tc_predef_replace_bitstring_6() runs on CT {
var bitstring vl_bs0 := '0000 1111'B
var bitstring vl_bs := replace(vl_bs0,0,2,'11'B);
if(vl_bs != '1100 1111'B){
setverdict(fail, "expected '11001111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 3 char compile time
testcase tc_predef_replace_bitstring_7() runs on CT {
var bitstring vl_bs := replace('0000 1111'B,0,2,'111'B);
if(vl_bs != '11100 1111'B){
setverdict(fail, "expected '111001111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 3 char runtime
testcase tc_predef_replace_bitstring_8() runs on CT {
var bitstring vl_bs0 := '0000 1111'B
var bitstring vl_bs := replace(vl_bs0,0,2,'111'B);
if(vl_bs != '11100 1111'B){
setverdict(fail, "expected '111001111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the second char (index position 1), insert 3 char compile time
testcase tc_predef_replace_bitstring_9() runs on CT {
var bitstring vl_bs := replace('0000 1111'B,1,2,'111'B);
if(vl_bs != '0 1110 1111'B){
setverdict(fail, "expected '011101111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the second char (index position 1), insert 3 char runtime
testcase tc_predef_replace_bitstring_10() runs on CT {
var bitstring vl_bs0 := '0000 1111'B
var bitstring vl_bs := replace(vl_bs0,1,2,'111'B);
if(vl_bs != '011101111'B){
setverdict(fail, "expected '011101111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
// append 3 chars compile time
testcase tc_predef_replace_bitstring_11() runs on CT {
var bitstring vl_bs := replace('0000 1111'B,8,0,'011'B);
if(vl_bs != '0000 1111 011'B){
setverdict(fail, "expected '00001111011'B got:", vl_bs);
} else {
setverdict(pass);
}
}
// append 3 char runtime
testcase tc_predef_replace_bitstring_12() runs on CT {
var bitstring vl_bs0 := '0000 1111'B
var bitstring vl_bs := replace(vl_bs0,8,0,'011'B);
if(vl_bs != '0000 1111 011'B){
setverdict(fail, "expected '00001111011'B got:", vl_bs);
} else {
setverdict(pass);
}
}
//Expected on-the-fly semantic marker:
//The sum of the second operand (8) and the third operand (1) of operation `replace' is greater than the length of the first operand (8)
//testcase tc_predef_replace_bitstring_13_bad() runs on CT {
// var bitstring vl_bs := replace('0000 1111'B,8,1,'011'B);
//}
//too long index: 8+1
testcase tc_predef_replace_bitstring_14_bad() runs on CT {
var bitstring vl_bs0 := '0000 1111'B
@try {
var bitstring vl_bs := replace(vl_bs0,8,1,'011'B);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//Expected on-the-fly semantic marker:
//The sum of the second operand (8) and the third operand (1) of operation `replace' is greater than the length of the first operand (8)
//testcase tc_predef_replace_bitstring_15_bad() runs on CT {
// var bitstring vl_bs := replace('0000 1111'B,7,2,'011'B);
//}
////Expected on-the-fly semantic marker:
////The third operand of operation `replace' should not be negative
//testcase tc_predef_replace_bitstring_15a_bad() runs on CT {
// var bitstring vl_bs := replace('0000 1111'B,7,-2,'011'B);
//}
//testcase tc_predef_replace_bitstring_15b_bad() runs on CT {
// var bitstring vl_bs := replace('0000 1111'B,7,-2,'11'H);
//}
//too long index: 7+2
testcase tc_predef_replace_bitstring_16_bad() runs on CT {
var bitstring vl_bs0 := '0000 1111'B
@try {
var bitstring vl_bs := replace(vl_bs0,7,2,'011'B);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//too long index: 9+0
testcase tc_predef_replace_bitstring_18_bad() runs on CT {
var bitstring vl_bs0 := '0000 1111'B
@try {
var bitstring vl_bs := replace(vl_bs0,9,0,'011'B);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//negative index:
testcase tc_predef_replace_bitstring_19_bad() runs on CT {
var bitstring vl_bs0 := '0000 1111'B
var integer idx := -1;
@try {
var bitstring vl_bs := replace(vl_bs0,idx,0,'011'B);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//negative length
testcase tc_predef_replace_bitstring_20_bad() runs on CT {
var bitstring vl_bs0 := '0000 1111'B
var integer idx := 0, len := -1;
@try {
var bitstring vl_bs := replace(vl_bs0,idx,len,'011'B);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//uninitialized str to be inserted
testcase tc_predef_replace_bitstring_21_bad() runs on CT {
var bitstring vl_bs0 := '0000 1111'B;
var bitstring vl_bs1;//uninit!
var integer idx := 0, len := 1;
@try {
var bitstring vl_bs := replace(vl_bs0,idx,len, vl_bs1);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//uninitialized input string
testcase tc_predef_replace_bitstring_22_bad() runs on CT {
var bitstring vl_bs0 ; //uninit!
var integer idx := 0, len := 1;
@try {
var bitstring vl_bs := replace(vl_bs0,idx,len,'011'B);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
// bitstring template
// remove 2 chars from the beginnining,insert 2 char compile time
testcase tc_predef_replace_bitstring_23() runs on CT {
var template bitstring tl_bs0 := '0000 1111'B;
var template bitstring tl_bs1 := '11'B;
const integer idx := 0;
const integer len := 2
var bitstring vl_bs := replace(tl_bs0,idx,len,tl_bs1);
if(vl_bs != '1100 1111'B){
setverdict(fail, "expected '11001111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 2 char runtime
testcase tc_predef_replace_bitstring_24() runs on CT {
template bitstring tl_bs0 := '0000 1111'B;
template bitstring tl_bs1 := '11'B;
var integer idx := 0;
var integer len := 2
var bitstring vl_bs := replace(tl_bs0,idx,len,tl_bs1);
if(vl_bs != '1100 1111'B){
setverdict(fail, "expected '11001111'B got:", vl_bs);
} else {
setverdict(pass);
}
}
//*********** Replace() for hexstring ************
// remove 2 chars from the beginnining, compile time
testcase tc_predef_replace_hexstring_1() runs on CT {
var hexstring vl_bs := replace('0000 1111'H,0,2,''H);
if(vl_bs != '00 1111'H){
setverdict(fail, "expected '001111'H got:", vl_bs);
} else {
setverdict(pass);
}
}
//var pars
testcase tc_predef_replace_hexstring_1a() runs on CT {
var integer vl_beginning :=0, vl_len := 2;
var hexstring vl_bs := replace('0000 1111'H,vl_beginning,vl_len,''H);
if(vl_bs != '00 1111'H){
setverdict(fail, "expected '001111'H got:", vl_bs);
} else {
setverdict(pass);
}
}
//const pars
testcase tc_predef_replace_hexstring_1b() runs on CT {
const integer vl_beginning :=0, vl_len := 2;
var hexstring vl_bs := replace('0000 1111'H,vl_beginning,vl_len,''H);
if(vl_bs != '00 1111'H){
setverdict(fail, "expected '001111'H got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining, run time
testcase tc_predef_replace_hexstring_2() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
var hexstring vl_bs := replace(vl_bs0,0,2,''H);
if(vl_bs != '00 1111'H){
setverdict(fail, "expected '001111'H got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining, run time
//parameters are variables
testcase tc_predef_replace_hexstring_2a() runs on CT {
var integer vl_beginning :=0, vl_len := 2;
var hexstring vl_bs0 := '0000 1111'H
var hexstring vl_bs := replace(vl_bs0,vl_beginning,vl_len,''H);
if(vl_bs != '00 1111'H){
setverdict(fail, "expected '001111'H got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 1 char compile time
testcase tc_predef_replace_hexstring_3() runs on CT {
var hexstring vl_bs := replace('0000 1111'H,0,2,'1'H);
if(vl_bs != '100 1111'H){
setverdict(fail, "expected '1001111'H got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 1 char runtime
testcase tc_predef_replace_hexstring_4() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
var hexstring vl_bs := replace(vl_bs0,0,2,'1'H);
if(vl_bs != '100 1111'H){
setverdict(fail, "expected '1001111'H got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 2 char compile time
testcase tc_predef_replace_hexstring_5() runs on CT {
var hexstring vl_bs := replace('0000 1111'H,0,2,'11'H);
if(vl_bs != '1100 1111'H){
setverdict(fail, "expected '11001111'H got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 2 char runtime
testcase tc_predef_replace_hexstring_6() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
var hexstring vl_bs := replace(vl_bs0,0,2,'11'H);
if(vl_bs != '1100 1111'H){
setverdict(fail, "expected '11001111'H got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 3 char compile time
testcase tc_predef_replace_hexstring_7() runs on CT {
var hexstring vl_bs := replace('0000 1111'H,0,2,'111'H);
if(vl_bs != '11100 1111'H){
setverdict(fail, "expected '111001111'H got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 3 char runtime
testcase tc_predef_replace_hexstring_8() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
var hexstring vl_bs := replace(vl_bs0,0,2,'111'H);
if(vl_bs != '11100 1111'H){
setverdict(fail, "expected '111001111'H got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the second char (index position 1), insert 3 char compile time
testcase tc_predef_replace_hexstring_9() runs on CT {
var hexstring vl_bs := replace('0000 1111'H,1,2,'111'H);
if(vl_bs != '0 1110 1111'H){
setverdict(fail, "expected '011101111'H got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the second char (index position 1), insert 3 char runtime
testcase tc_predef_replace_hexstring_10() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
var hexstring vl_bs := replace(vl_bs0,1,2,'111'H);
if(vl_bs != '011101111'H){
setverdict(fail, "expected '011101111'H got:", vl_bs);
} else {
setverdict(pass);
}
}
// append 3 chars compile time
testcase tc_predef_replace_hexstring_11() runs on CT {
var hexstring vl_bs := replace('0000 1111'H,8,0,'011'H);
if(vl_bs != '0000 1111 011'H){
setverdict(fail, "expected '00001111011'H got:", vl_bs);
} else {
setverdict(pass);
}
}
// append 3 char runtime
testcase tc_predef_replace_hexstring_12() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
var hexstring vl_bs := replace(vl_bs0,8,0,'011'H);
if(vl_bs != '0000 1111 011'H){
setverdict(fail, "expected '00001111011'H got:", vl_bs);
} else {
setverdict(pass);
}
}
//Expected on-the-fly semantic marker:
//The sum of the second operand (8) and the third operand (1) of operation `replace' is greater than the length of the first operand (8)
//testcase tc_predef_replace_hexstring_13_bad() runs on CT {
// var hexstring vl_bs := replace('0000 1111'H,8,1,'011'H);
//}
//too long index: 8+1
testcase tc_predef_replace_hexstring_14_bad() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
@try {
var hexstring vl_bs := replace(vl_bs0,8,1,'011'H);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//Expected on-the-fly semantic marker:
//The sum of the second operand (8) and the third operand (1) of operation `replace' is greater than the length of the first operand (8)
//testcase tc_predef_replace_hexstring_15_bad() runs on CT {
// var hexstring vl_bs := replace('0000 1111'H,7,2,'011'H);
//}
////Expected on-the-fly semantic marker:
////The third operand of operation `replace' should not be negative
//testcase tc_predef_replace_hexstring_15a_bad() runs on CT {
// var hexstring vl_bs := replace('0000 1111'H,7,-2,'011'H);
//}
//testcase tc_predef_replace_hexstring_15b_bad() runs on CT {
// var hexstring vl_bs := replace('0000 1111'H,7,-2,'11'H);
//}
//too long index: 7+2
testcase tc_predef_replace_hexstring_16_bad() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
@try {
var hexstring vl_bs := replace(vl_bs0,7,2,'011'H);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//too long index: 9+0
testcase tc_predef_replace_hexstring_18_bad() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
@try {
var hexstring vl_bs := replace(vl_bs0,9,0,'011'H);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//too long index: 7+2, runtime
testcase tc_predef_replace_hexstring_19() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
var hexstring vl_bs1 := '011'H;
var integer idx := 7;
var integer len := 2;
@try {
var hexstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//too long index: 9+0, runtime
testcase tc_predef_replace_hexstring_20() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
var hexstring vl_bs1 := '011'H;
var integer idx := 9;
var integer len := 0;
@try {
var hexstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//negative index
testcase tc_predef_replace_hexstring_21() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
var hexstring vl_bs1 := '011'H;
var integer idx := -1;
var integer len := 2;
@try {
var hexstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//negative length
testcase tc_predef_replace_hexstring_22() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
var hexstring vl_bs1 := '011'H;
var integer idx := 0;
var integer len := -2;
@try {
var hexstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//uninit original string
testcase tc_predef_replace_hexstring_23() runs on CT {
var hexstring vl_bs0;
var hexstring vl_bs1 := '011'H;
var integer idx := 0;
var integer len := 0;
@try {
var hexstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//uninit string to be inserted
testcase tc_predef_replace_hexstring_24() runs on CT {
var hexstring vl_bs0 := '0000 1111'H
var hexstring vl_bs1 ;
var integer idx := 0;
var integer len := 0;
@try {
var hexstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
// var templates. append 3 char runtime
testcase tc_predef_replace_hexstring_25() runs on CT {
var template hexstring vl_bs0 := '0000 1111'H
var template hexstring vl_bs1 := '011'H;
var integer idx := 8;
var integer len := 0;
var hexstring vl_bs := replace(vl_bs0,idx,len, vl_bs1);
if(vl_bs != '0000 1111 011'H){
setverdict(fail, "expected '00001111011'H got:", vl_bs);
} else {
setverdict(pass);
}
}
// const local templates. append 3 char runtime
testcase tc_predef_replace_hexstring_26() runs on CT {
template hexstring vl_bs0 := '0000 1111'H
template hexstring vl_bs1 := '011'H;
var integer idx := 8;
var integer len := 0;
var hexstring vl_bs := replace(vl_bs0,idx,len, vl_bs1);
if(vl_bs != '0000 1111 011'H){
setverdict(fail, "expected '00001111011'H got:", vl_bs);
} else {
setverdict(pass);
}
}
//*********** Replace() for octetstring **********
// remove 2 chars from the beginnining, compile time
testcase tc_predef_replace_octetstring_1() runs on CT {
var octetstring vl_bs := replace('0000 1111'O,0,1,''O);
if(vl_bs != '00 1111'O){
setverdict(fail, "expected '001111'O got:", vl_bs);
} else {
setverdict(pass);
}
}
//var pars
testcase tc_predef_replace_octetstring_1a() runs on CT {
var integer vl_beginning :=0, vl_len := 1;
var octetstring vl_os := replace('0000 1111'O,vl_beginning,vl_len,''O);
if(vl_os != '00 1111'O){
setverdict(fail, "expected '001111'O got:", vl_os);
} else {
setverdict(pass);
}
}
//const pars
testcase tc_predef_replace_octetstring_1b() runs on CT {
const integer vl_beginning :=0, vl_len := 1;
var octetstring vl_os := replace('0000 1111'O,vl_beginning,vl_len,''O);
if(vl_os != '00 1111'O){
setverdict(fail, "expected '001111'O got:", vl_os);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining, run time
testcase tc_predef_replace_octetstring_2() runs on CT {
var octetstring vl_os0 := '0000 1111'O
var octetstring vl_os := replace(vl_os0,0,1,''O);
if(vl_os != '00 1111'O){
setverdict(fail, "expected '001111'O got:", vl_os);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining, run time
//parameters are variables
testcase tc_predef_replace_octetstring_2a() runs on CT {
var integer vl_beginning :=0, vl_len := 1;
var octetstring vl_os0 := '0000 1111'O
var octetstring vl_os := replace(vl_os0,vl_beginning,vl_len,''O);
if(vl_os != '00 1111'O){
setverdict(fail, "expected '001111'O got:", vl_os);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 1 char compile time
testcase tc_predef_replace_octetstring_3() runs on CT {
var octetstring vl_os := replace('0000 1111'O,0,1,'11'O);
if(vl_os != '1100 1111'O){
setverdict(fail, "expected '11001111'O got:", vl_os);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 1 char runtime
testcase tc_predef_replace_octetstring_4() runs on CT {
var octetstring vl_os0 := '0000 1111'O
var octetstring vl_os := replace(vl_os0,0,1,'11'O);
if(vl_os != '1100 1111'O){
setverdict(fail, "expected '11001111'O got:", vl_os);
} else {
setverdict(pass);
}
}
// remove 4 chars from the beginnining,insert 2 char compile time
testcase tc_predef_replace_octetstring_5() runs on CT {
var octetstring vl_os := replace('0000 1111'O,0,2,'11'O);
if(vl_os != '11 1111'O){
setverdict(fail, "expected '111111'O got:", vl_os);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 2 char runtime
testcase tc_predef_replace_octetstring_6() runs on CT {
var octetstring vl_os0 := '0000 1111'O
var octetstring vl_os := replace(vl_os0,0,2,'11'O);
if(vl_os != '11 1111'O){
setverdict(fail, "expected '111111'O got:", vl_os);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 3 char compile time
testcase tc_predef_replace_octetstring_7() runs on CT {
var octetstring vl_os := replace('0000 1111'O,0,2,'1111'O);
if(vl_os != '1111 1111'O){
setverdict(fail, "expected '11111111'O got:", vl_os);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 3 char runtime
testcase tc_predef_replace_octetstring_8() runs on CT {
var octetstring vl_os0 := '0000 1111'O
var octetstring vl_os := replace(vl_os0,0,2,'1111'O);
if(vl_os != '1111 1111'O){
setverdict(fail, "expected '11111111'O got:", vl_os);
} else {
setverdict(pass);
}
}
// remove 2 chars from the second char (index position 1), insert 3 char compile time
testcase tc_predef_replace_octetstring_9() runs on CT {
var octetstring vl_os := replace('0000 1111'O,1,2,'1111'O);
if(vl_os != '00 1111 11'O){
setverdict(fail, "expected '00111111'O got:", vl_os);
} else {
setverdict(pass);
}
}
// remove 2 chars from the second char (index position 1), insert 3 char runtime
testcase tc_predef_replace_octetstring_10() runs on CT {
var octetstring vl_os0 := '0000 1111'O
var octetstring vl_os := replace(vl_os0,1,2,'1111'O);
if(vl_os != '00111111'O){
setverdict(fail, "expected '00111111'O got:", vl_os);
} else {
setverdict(pass);
}
}
// append 4 chars compile time
testcase tc_predef_replace_octetstring_11() runs on CT {
var octetstring vl_os := replace('0000 1111'O,4,0,'0011'O);
if(vl_os != '0000 1111 0011'O){
setverdict(fail, "expected '000011110011'O got:", vl_os);
} else {
setverdict(pass);
}
}
// append 3 char runtime
testcase tc_predef_replace_octetstring_12() runs on CT {
var octetstring vl_os0 := '0000 1111'O
var octetstring vl_os := replace(vl_os0,4,0,'0011'O);
if(vl_os != '0000 1111 0011'O){
setverdict(fail, "expected '000011110011'O got:", vl_os);
} else {
setverdict(pass);
}
}
//Expected on-the-fly semantic marker:
//The sum of the second operand (8) and the third operand (1) of operation `replace' is greater than the length of the first operand (8)
//testcase tc_predef_replace_octetstring_13_bad() runs on CT {
// var octetstring vl_os := replace('0000 1111'O,8,1,'011'O);
//}
//too long index: 4+1, perhaps compile time
testcase tc_predef_replace_octetstring_14_bad() runs on CT {
var octetstring vl_os0 := '0000 1111'O
@try {
var octetstring vl_os := replace(vl_os0,4,1,'0011'O);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//Expected on-the-fly semantic marker:
//The sum of the second operand (8) and the third operand (1) of operation `replace' is greater than the length of the first operand (8)
//testcase tc_predef_replace_octetstring_15_bad() runs on CT {
// var octetstring vl_os := replace('0000 1111'O,3,2,'0011'O);
//}
////Expected on-the-fly semantic marker:
////The third operand of operation `replace' should not be negative
//testcase tc_predef_replace_octetstring_15a_bad() runs on CT {
// var octetstring vl_os := replace('0000 1111'O,3,-2,'0011'O);
//}
//testcase tc_predef_replace_octetstring_15b_bad() runs on CT {
// var octetstring vl_os := replace('0000 1111'O,3,-2,'11'O);
//}
//too long index: 3+2
testcase tc_predef_replace_octetstring_16_bad() runs on CT {
var octetstring vl_os0 := '0000 1111'O
@try {
var octetstring vl_os := replace(vl_os0,3,2,'0011'O);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//too long index: 5+0
testcase tc_predef_replace_octetstring_18_bad() runs on CT {
var octetstring vl_os0 := '0000 1111'O
@try {
var octetstring vl_os := replace(vl_os0,5,0,'0011'O);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//too long index: 5+0, runtime
testcase tc_predef_replace_octetstring_19_bad() runs on CT {
var octetstring vl_os0 := '0000 1111'O
var octetstring vl_os1 := '0011'O;
var integer idx := 5;
var integer len := 0;
@try {
var octetstring vl_os := replace(vl_os0,idx,len,vl_os1);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//too long index: 3+2, runtime
testcase tc_predef_replace_octetstring_20_bad() runs on CT {
var octetstring vl_os0 := '0000 1111'O
var octetstring vl_os1 := '0011'O;
var integer idx := 3;
var integer len := 2;
@try {
var octetstring vl_os := replace(vl_os0,idx,len,vl_os1);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//negative index
testcase tc_predef_replace_octetstring_21_bad() runs on CT {
var octetstring vl_os0 := '0000 1111'O
var octetstring vl_os1 := '0011'O;
var integer idx := -1;
var integer len := 2;
@try {
var octetstring vl_os := replace(vl_os0,idx,len,vl_os1);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//negative length
testcase tc_predef_replace_octetstring_22_bad() runs on CT {
var octetstring vl_os0 := '0000 1111'O
var octetstring vl_os1 := '0011'O;
var integer idx := 3;
var integer len := -2;
@try {
var octetstring vl_os := replace(vl_os0,idx,len,vl_os1);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//uninit orig str
testcase tc_predef_replace_octetstring_23_bad() runs on CT {
var octetstring vl_os0;
var octetstring vl_os1 := '0011'O;
var integer idx := 3;
var integer len := -2;
@try {
var octetstring vl_os := replace(vl_os0,idx,len,vl_os1);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//uninit string to be inserted
testcase tc_predef_replace_octetstring_24_bad() runs on CT {
var octetstring vl_os0 := '0000 1111'O
var octetstring vl_os1;
var integer idx := 3;
var integer len := -2;
@try {
var octetstring vl_os := replace(vl_os0,idx,len,vl_os1);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
// var templates, append 3 char runtime
testcase tc_predef_replace_octetstring_25() runs on CT {
var template octetstring vl_os0 := '0000 1111'O
var template octetstring vl_os1 := '0011'O;
var integer idx := 4;
var integer len := 0;
var octetstring vl_os := replace(vl_os0, idx, len, vl_os1);
if(vl_os != '0000 1111 0011'O){
setverdict(fail, "expected '000011110011'O got:", vl_os);
} else {
setverdict(pass);
}
}
// templates, append 3 char runtime
testcase tc_predef_replace_octetstring_26() runs on CT {
template octetstring vl_os0 := '0000 1111'O
template octetstring vl_os1 := '0011'O;
var integer idx := 4;
var integer len := 0;
var octetstring vl_os := replace(vl_os0, idx, len, vl_os1);
if(vl_os != '0000 1111 0011'O){
setverdict(fail, "expected '000011110011'O got:", vl_os);
} else {
setverdict(pass);
}
}
//*********** Replace() for charstring ***********
// remove 2 chars from the beginnining, compile time
testcase tc_predef_replace_charstring_1() runs on CT {
var charstring vl_bs := replace("0000 1111",0,2,"");
if(vl_bs != "00 1111"){
setverdict(fail, "expected \"001111\" got:", vl_bs);
} else {
setverdict(pass);
}
}
//var pars
testcase tc_predef_replace_charstring_1a() runs on CT {
var integer vl_beginning :=0, vl_len := 2;
var charstring vl_bs := replace("0000 1111",vl_beginning,vl_len,"");
if(vl_bs != "00 1111"){
setverdict(fail, "expected \"001111\" got:", vl_bs);
} else {
setverdict(pass);
}
}
//const pars
testcase tc_predef_replace_charstring_1b() runs on CT {
const integer vl_beginning :=0, vl_len := 2;
var charstring vl_bs := replace("0000 1111",vl_beginning,vl_len,"");
if(vl_bs != "00 1111"){
setverdict(fail, "expected \"001111\" got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining, run time
testcase tc_predef_replace_charstring_2() runs on CT {
var charstring vl_bs0 := "0000 1111"
var charstring vl_bs := replace(vl_bs0,0,2,"");
if(vl_bs != "00 1111"){
setverdict(fail, "expected \"001111\" got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining, run time
//parameters are variables
testcase tc_predef_replace_charstring_2a() runs on CT {
var integer vl_beginning :=0, vl_len := 2;
var charstring vl_bs0 := "0000 1111"
var charstring vl_bs := replace(vl_bs0,vl_beginning,vl_len,"");
if(vl_bs != "00 1111"){
setverdict(fail, "expected \"001111\" got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 1 char compile time
testcase tc_predef_replace_charstring_3() runs on CT {
var charstring vl_bs := replace("0000 1111",0,2,"1");
if(vl_bs != "100 1111"){
setverdict(fail, "expected \"1001111\" got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 1 char runtime
testcase tc_predef_replace_charstring_4() runs on CT {
var charstring vl_bs0 := "0000 1111"
var charstring vl_bs := replace(vl_bs0,0,2,"1");
if(vl_bs != "100 1111"){
setverdict(fail, "expected \"1001111\" got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 2 char compile time
testcase tc_predef_replace_charstring_5() runs on CT {
var charstring vl_bs := replace("0000 1111",0,2,"11");
if(vl_bs != "1100 1111"){
setverdict(fail, "expected \"11001111\" got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 2 char runtime
testcase tc_predef_replace_charstring_6() runs on CT {
var charstring vl_bs0 := "0000 1111"
var charstring vl_bs := replace(vl_bs0,0,2,"11");
if(vl_bs != "1100 1111"){
setverdict(fail, "expected \"11001111\" got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 3 char compile time
testcase tc_predef_replace_charstring_7() runs on CT {
var charstring vl_bs := replace("0000 1111",0,2,"111");
if(vl_bs != "11100 1111"){
setverdict(fail, "expected \"11100 1111\" got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 3 char runtime
testcase tc_predef_replace_charstring_8() runs on CT {
var charstring vl_bs0 := "00001111"
var charstring vl_bs := replace(vl_bs0,0,2,"111");
if(vl_bs != "111001111"){
setverdict(fail, "expected \"111001111\" got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the second char (index position 1), insert 3 char compile time
testcase tc_predef_replace_charstring_9() runs on CT {
var charstring vl_bs := replace("00001111",1,2,"111");
if(vl_bs != "011101111"){
setverdict(fail, "expected \"011101111\" got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the second char (index position 1), insert 3 char runtime
testcase tc_predef_replace_charstring_10() runs on CT {
var charstring vl_bs0 := "00001111"
var charstring vl_bs := replace(vl_bs0,1,2,"111");
if(vl_bs != "011101111"){
setverdict(fail, "expected \"011101111\" got:", vl_bs);
} else {
setverdict(pass);
}
}
// append 3 chars compile time
testcase tc_predef_replace_charstring_11() runs on CT {
var charstring vl_bs := replace("00001111",8,0,"011");
if(vl_bs != "00001111011"){
setverdict(fail, "expected \"00001111011\" got:", vl_bs);
} else {
setverdict(pass);
}
}
// append 3 char runtime
testcase tc_predef_replace_charstring_12() runs on CT {
var charstring vl_bs0 := "00001111"
var charstring vl_bs := replace(vl_bs0,8,0,"011");
if(vl_bs != "00001111011"){
setverdict(fail, "expected \"00001111011\" got:", vl_bs);
} else {
setverdict(pass);
}
}
//Expected on-the-fly semantic marker:
//The sum of the second operand (8) and the third operand (1) of operation `replace" is greater than the length of the first operand (8)
//testcase tc_predef_replace_charstring_13_bad() runs on CT {
// var charstring vl_bs := replace("0000 1111",8,1,"011");
//}
//too long index: 8+1
testcase tc_predef_replace_charstring_14_bad() runs on CT {
var charstring vl_bs0 := "00001111"
@try {
var charstring vl_bs := replace(vl_bs0,8,1,"011");
setverdict(fail,"DTE expected, got:", vl_bs)
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//Expected on-the-fly semantic marker:
//The sum of the second operand (8) and the third operand (1) of operation `replace" is greater than the length of the first operand (8)
//testcase tc_predef_replace_charstring_15_bad() runs on CT {
// var charstring vl_bs := replace("0000 1111",7,2,"011");
//}
////Expected on-the-fly semantic marker:
////The third operand of operation `replace" should not be negative
//testcase tc_predef_replace_charstring_15a_bad() runs on CT {
// var charstring vl_bs := replace("00001111",7,-2,"011");
//}
//testcase tc_predef_replace_charstring_15b_bad() runs on CT {
// var charstring vl_bs := replace("00001111",7,-2,"11"H);
//}
//too long index: 7+2
testcase tc_predef_replace_charstring_16_bad() runs on CT {
var charstring vl_bs0 := "00001111"
@try {
var charstring vl_bs := replace(vl_bs0,7,2,"011");
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//too long index: 9+0
testcase tc_predef_replace_charstring_18_bad() runs on CT {
var charstring vl_bs0 := "00001111"
@try {
var charstring vl_bs := replace(vl_bs0,9,0,"011");
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//********** Replace for RoI *******************
// remove 2 chars from the beginnining, compile time
testcase tc_predef_replace_RoI_1() runs on CT {
const RoI vl_roi := {0,1,2,3,4,5,6,7};
const RoI vl_bs := replace(vl_roi,0,2,c_roi_empty);
if(vl_bs != {2,3,4,5,6,7}){
setverdict(fail, "expected {2,3,4,5,6,7} got:", vl_bs);
} else {
setverdict(pass);
}
}
//var pars
testcase tc_predef_replace_RoI_1a() runs on CT {
const RoI vl_roi := {0,1,2,3,4,5,6,7};
const integer vl_beginning :=0, vl_len := 2;
var RoI vl_bs := replace(vl_roi,vl_beginning,vl_len,c_roi_empty);
if(vl_bs != {2,3,4,5,6,7}){
setverdict(fail, "expected {2,3,4,5,6,7,} got:", vl_bs);
} else {
setverdict(pass);
}
}
//const pars
testcase tc_predef_replace_RoI_1b() runs on CT {
var RoI vl_roi := {0,1,2,3,4,5,6,7};
var integer vl_beginning := 0, vl_len := 2;
var RoI vl_bs := replace(vl_roi,vl_beginning,vl_len,c_roi_empty);
if(vl_bs != {2,3,4,5,6,7}){
setverdict(fail, "expected {2,3,4,5,6,7} got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining, run time
testcase tc_predef_replace_RoI_2() runs on CT {
var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
var RoI vl_bs := replace(vl_bs0,0,2,c_roi_empty);
if(vl_bs != {2,3,4,5,6,7}){
setverdict(fail, "expected {2,3,4,5,6,7} got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 elements from the beginnining, run time
//parameters are variables
testcase tc_predef_replace_RoI_2a() runs on CT {
var integer vl_beginning :=0, vl_len := 2;
var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
var RoI vl_bs := replace(vl_bs0,vl_beginning,vl_len,c_roi_empty);
if(vl_bs != {2,3,4,5,6,7}){
setverdict(fail, "expected {2,3,4,5,6,7} got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 1 char compile time
testcase tc_predef_replace_RoI_3() runs on CT {
const RoI vl_roi := {0,1,2,3,4,5,6,7};
const RoI vl_bs := replace(vl_roi,0,2,c_roi_1);
if(vl_bs != {-1,2,3,4,5,6,7}){
setverdict(fail, "expected {-1,2,3,4,5,6,7} got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 1 char runtime
testcase tc_predef_replace_RoI_4() runs on CT {
var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
var RoI vl_bs := replace(vl_bs0,0,2,c_roi_1);
if(vl_bs != {-1,2,3,4,5,6,7}){
setverdict(fail, "expected {-1,2,3,4,5,6,7} got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 2 char compile time
testcase tc_predef_replace_RoI_5() runs on CT {
const RoI vl_bs0 := {0,1,2,3,4,5,6,7}
const RoI vl_bs := replace(vl_bs0,0,2,c_roi_2);
if(vl_bs != {-2,-1,2,3,4,5,6,7}){
setverdict(fail, "expected {-2,-1,2,3,4,5,6,7} got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 2 char runtime
testcase tc_predef_replace_RoI_6() runs on CT {
var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
var RoI vl_bs := replace(vl_bs0,0,2, c_roi_2);
if(vl_bs != {-2,-1,2,3,4,5,6,7}){
setverdict(fail, "expected {-2,-1,2,3,4,5,6,7} got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 3 char compile time
testcase tc_predef_replace_RoI_7() runs on CT {
const RoI vl_bs0 := {0,1,2,3,4,5,6,7}
const RoI vl_bs := replace(vl_bs0,0,2, c_roi_2 & {-3} );
if(vl_bs != {-2,-1,-3,2,3,4,5,6,7}){
setverdict(fail, "expected {-2,-1,-3,2,3,4,5,6,7} got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the beginnining,insert 3 char runtime
testcase tc_predef_replace_RoI_8() runs on CT {
var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
const RoI vl_roi3 := {-3,-2,-1}
var RoI vl_bs := replace(vl_bs0,0,2,vl_roi3);
if(vl_bs != {-3,-2,-1,2,3,4,5,6,7}){
setverdict(fail, "expected {-3,-2,-1,2,3,4,5,6,7} got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the second char (index position 1), insert 3 char compile time
testcase tc_predef_replace_RoI_9() runs on CT {
var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
var RoI vl_bs := replace(vl_bs0,1,2,c_roi3);
if(vl_bs != {0,-3,-2,-1,3,4,5,6,7}){
setverdict(fail, "expected {0,-3,-2,-1,3,4,5,6,7} got:", vl_bs);
} else {
setverdict(pass);
}
}
// remove 2 chars from the second char (index position 1), insert 3 char runtime
testcase tc_predef_replace_RoI_10() runs on CT {
var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
const RoI vl_roi3 := {-3,-2,-1}
var RoI vl_bs := replace(vl_bs0,1,2,vl_roi3);
if(vl_bs != {0,-3,-2,-1,3,4,5,6,7}){
setverdict(fail, "expected {0,-3,-2,-1,3,4,5,6,7} got:", vl_bs);
} else {
setverdict(pass);
}
}
// append 3 chars compile time
testcase tc_predef_replace_RoI_11() runs on CT {
const RoI vl_bs0 := {0,1,2,3,4,5,6,7}
const RoI vl_bs := replace(vl_bs0,8,0,c_roi3);
if(vl_bs != {0,1,2,3,4,5,6,7,-3,-2,-1}){
setverdict(fail, "expected {0,1,2,3,4,5,6,7,-3,-2,-1} got:", vl_bs);
} else {
setverdict(pass);
}
}
// append 3 char runtime
testcase tc_predef_replace_RoI_12() runs on CT {
var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
var RoI vl_bs := replace(vl_bs0,8,0,c_roi3);
if(vl_bs != {0,1,2,3,4,5,6,7,-3,-2,-1}){
setverdict(fail, "expected {0,1,2,3,4,5,6,7,-3,-2,-1} got:", vl_bs);
} else {
setverdict(pass);
}
}
//Expected on-the-fly semantic marker:
//The sum of the second operand (8) and the third operand (1) of operation `replace" is greater than the length of the first operand (8)
//testcase tc_predef_replace_RoI_13_bad() runs on CT {
// const RoI vl_bs0 := {0,1,2,3,4,5,6,7}
// @try {
// var RoI vl_bs := replace(vl_bs0,8,1,c_roi3);
// setverdict(fail,"DTE expected, got:", vl_bs)
// }
// @catch(e) {
// setverdict(pass,"Expected DTE catched")
// }
//}
//too long index: 8+1, runtime recognition
testcase tc_predef_replace_RoI_14_bad() runs on CT {
var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
var integer vl_len := 1;
@try {
var RoI vl_bs := replace(vl_bs0,8,1,c_roi3);
setverdict(fail,"DTE expected, got:", vl_bs)
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//Expected on-the-fly semantic marker:
//The sum of the second operand (8) and the third operand (1) of operation `replace" is greater than the length of the first operand (8)
//testcase tc_predef_replace_RoI_15_bad() runs on CT {
// var RoI vl_bs := replace({0,1,2,3,4,5,6,7},7,2,"011");
//}
////Expected on-the-fly semantic marker:
////The third operand of operation `replace" should not be negative
//testcase tc_predef_replace_RoI_15a_bad() runs on CT {
// var RoI vl_bs := replace("00001111",7,-2,"011");
//}
//testcase tc_predef_replace_RoI_15b_bad() runs on CT {
// var RoI vl_bs := replace("00001111",7,-2,"11"H);
//}
//too long index: 7+2
testcase tc_predef_replace_RoI_16_bad() runs on CT {
var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
@try {
var RoI vl_bs := replace(vl_bs0,7,2,c_roi3);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//too long index: 9+0
testcase tc_predef_replace_RoI_18_bad() runs on CT {
var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
@try {
var RoI vl_bs := replace(vl_bs0,9,0,c_roi3);
setverdict(fail,"DTE expected")
}
@catch(e) {
setverdict(pass,"Expected DTE catched")
}
}
//======== str2bit ==========
testcase tc_predef_str2bit_good1() runs on CT {
var RoCS vl_roc := {"","01","00001111","11110000111100001","1111000011110000111110000111100001"}
var RoBS vl_expected := {''B,'01'B,'0000 1111'B,'11110000111100001'B,'1111000011110000111110000111100001'B}
var integer N := sizeof( vl_roc );
for(var integer i:=0;i<N; i:=i+1) {
if(str2bit(vl_roc[i])!=vl_expected[i]) {
setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",str2bit(vl_roc[i]));
}
}
setverdict(pass);
}
//compile time cases
testcase tc_predef_str2bit_good2() runs on CT {
const charstring vl_cs := "11110000111100001";
const bitstring vl_bs := '11110000111100001'B;
if(str2bit(vl_cs)!= vl_bs){
setverdict(fail,"expected:", vl_bs," got: ", str2bit(vl_cs));
}
setverdict(pass);
}
testcase tc_predef_str2bit_good2a() runs on CT {
const charstring vl_cs := "";
const bitstring vl_bs := ''B;
if(str2bit(vl_cs)!= vl_bs){
setverdict(fail,"expected: ''B got: ", str2bit(vl_cs));
}
setverdict(pass);
}
testcase tc_predef_str2bit_good3() runs on CT {
const charstring vl_cs := "11110000111100001";
const bitstring vl_bs := '11110000111100001'B;
var integer N := lengthof(vl_cs);
for( var integer i:=0;i<N;i:=i+1) {
if(str2bit(vl_cs[i])!= vl_bs[i]){
setverdict(fail,i,": expected:", vl_bs[i]," got: ", str2bit(vl_cs[i]));
}
}
setverdict(pass);
}
//str2float -- see at the beginning!
//str2hex
testcase tc_predef_str2hex_good1() runs on CT {
var RoCS vl_roc := {"","01","00001111","11110000111100001","1111000011110000111110000111100001"}
var RoHS vl_expected := {''H,'01'H,'0000 1111'H,'11110000111100001'H,'1111000011110000111110000111100001'H}
var integer N := sizeof( vl_roc );
for(var integer i:=0;i<N; i:=i+1) {
if(str2hex(vl_roc[i])!=vl_expected[i]) {
setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",str2hex(vl_roc[i]));
}
}
setverdict(pass);
}
//compile time cases
testcase tc_predef_str2hex_good2() runs on CT {
const charstring vl_cs := "11110000111100001";
const hexstring vl_bs := '11110000111100001'H;
if(str2hex(vl_cs)!= vl_bs){
setverdict(fail,"expected:", vl_bs," got: ", str2hex(vl_cs));
}
setverdict(pass);
}
testcase tc_predef_str2hex_good2a() runs on CT {
const charstring vl_cs := "";
const hexstring vl_bs := ''H;
if(str2hex(vl_cs)!= vl_bs){
setverdict(fail,"expected: ''H got: ", str2hex(vl_cs));
}
setverdict(pass);
}
testcase tc_predef_str2hex_good3() runs on CT {
const charstring vl_cs := "11110000111100001";
const hexstring vl_bs := '11110000111100001'H;
var integer N := lengthof(vl_cs);
for( var integer i:=0;i<N;i:=i+1) {
if(str2hex(vl_cs[i])!= vl_bs[i]){
setverdict(fail,i,": expected:", vl_bs[i]," got: ", str2hex(vl_cs[i]));
}
}
setverdict(pass);
}
//str2int
testcase tc_predef_str2int_good1() runs on CT {
var RoCS vl_roc := {"01","00001111","111100001111000010","1111000011110000111110000111100001"}
var RoI vl_expected := { 1, 1111,111100001111000010,1111000011110000111110000111100001}
var integer N := sizeof( vl_roc );
for(var integer i:=0;i<N; i:=i+1) {
if(str2int(vl_roc[i])!=vl_expected[i]) {
setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",str2int(vl_roc[i]));
}
}
setverdict(pass);
}
//compile time cases
testcase tc_predef_str2int_good2() runs on CT {
const charstring vl_cs := "111100001111000010";
const integer vl_bs := 111100001111000010;
if(str2int(vl_cs)!= vl_bs){
setverdict(fail,"expected:", vl_bs," got: ", str2int(vl_cs));
}
setverdict(pass);
}
// semantic error, as it is required!
//testcase tc_predef_str2int_good2a() runs on CT {
// const charstring vl_cs := "";
// @try {
// const integer vl_bs := str2int(vl_cs);
// setverdict(fail,"expected: ''O got: ", str2oct(vl_cs));
// }
// @catch(e){
// setverdict(pass);
// }
//}
//str2oct
testcase tc_predef_str2oct_good1() runs on CT {
var RoCS vl_roc := {"","01","00001111","111100001111000010","1111000011110000111110000111100001"}
var RoOS vl_expected := {''O,'01'O,'0000 1111'O,'111100001111000010'O,'1111000011110000111110000111100001'O}
var integer N := sizeof( vl_roc );
for(var integer i:=0;i<N; i:=i+1) {
if(str2oct(vl_roc[i])!=vl_expected[i]) {
setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",str2oct(vl_roc[i]));
}
}
setverdict(pass);
}
//compile time cases
testcase tc_predef_str2oct_good2() runs on CT {
const charstring vl_cs := "111100001111000010";
const octetstring vl_bs := '111100001111000010'O;
if(str2oct(vl_cs)!= vl_bs){
setverdict(fail,"expected:", vl_bs," got: ", str2oct(vl_cs));
}
setverdict(pass);
}
testcase tc_predef_str2oct_good2a() runs on CT {
const charstring vl_cs := "";
const octetstring vl_bs := ''O;
if(str2oct(vl_cs)!= vl_bs){
setverdict(fail,"expected: ''O got: ", str2oct(vl_cs));
}
setverdict(pass);
}
//=============================================
//============ substring ======================
//=============================================
//--- bitstring ---
//compile time
testcase tc_predef_substring_bitstring1() runs on CT {
const bitstring vl_cs := ''B;
const bitstring vl_bs := substr(vl_cs, 0,0)
if(vl_bs!=''B){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_bitstring2() runs on CT {
var bitstring vl_cs := ''B;
var bitstring vl_bs := substr(vl_cs, 0,0);
log(vl_bs);
if( vl_bs!=''B){
setverdict(fail);
}
setverdict(pass);
}
testcase tc_predef_substring_bitstring3() runs on CT {
// const bitstring vl_cs := ''B;
const bitstring vl_bs := substr('00100110'B, 3, 4)
if(vl_bs!='0011'B){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_bitstring4() runs on CT {
var bitstring vl_cs := '00100110'B;
var bitstring vl_bs := substr(vl_cs, 3,4)
if(vl_bs!='0011'B){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_bitstring5() runs on CT {
const bitstring vl_cs := '00100110'B;
const bitstring vl_bs := substr(vl_cs, 3, 5)
if(vl_bs!='00110'B){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_bitstring6() runs on CT {
var bitstring vl_cs := '00100110'B;
var bitstring vl_bs := substr(vl_cs, 3,5)
if(vl_bs!='00110'B){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
//semantic error (before compile time)
//testcase tc_predef_substring_bitstring7() runs on CT {
// const bitstring vl_cs := '00100110'B;
// const bitstring vl_bs := substr(vl_cs, 3, 6)
// setverdict(fail);
//}
//runtime error
testcase tc_predef_substring_bitstring8() runs on CT {
var bitstring vl_cs := '00100110'B;
@try {
var bitstring vl_bs := substr(vl_cs, 3,6)
setverdict(fail,"DTE expected");
}
@catch(e){
setverdict(pass);
}
}
//semantic error (before compile time)
//testcase tc_predef_substring_bitstring9() runs on CT {
// const bitstring vl_cs := '00100110'B;
// const bitstring vl_bs := substr(vl_cs, 9, 0)
// setverdict(fail);
//}
//runtime error
testcase tc_predef_substring_bitstring10() runs on CT {
var bitstring vl_cs := '00100110'B;
@try {
var bitstring vl_bs := substr(vl_cs, 9,0)
setverdict(fail,"DTE expected");
}
@catch(e){
setverdict(pass);
}
}
//--- hexstring ---
//compile time
testcase tc_predef_substring_hexstring1() runs on CT {
const hexstring vl_cs := ''H;
const hexstring vl_bs := substr(vl_cs, 0,0)
if(vl_bs!=''H){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_hexstring2() runs on CT {
var hexstring vl_cs := ''H;
var hexstring vl_bs := substr(vl_cs, 0,0);
log(vl_bs);
if( vl_bs!=''H){
setverdict(fail);
}
setverdict(pass);
}
testcase tc_predef_substring_hexstring3() runs on CT {
// const hexstring vl_cs := ''H;
const hexstring vl_bs := substr('00100110'H, 3, 4)
if(vl_bs!='0011'H){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_hexstring4() runs on CT {
var hexstring vl_cs := '00100110'H;
var hexstring vl_bs := substr(vl_cs, 3,4)
if(vl_bs!='0011'H){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_hexstring5() runs on CT {
const hexstring vl_cs := '00100110'H;
const hexstring vl_bs := substr(vl_cs, 3, 5)
if(vl_bs!='00110'H){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_hexstring6() runs on CT {
var hexstring vl_cs := '00100110'H;
var hexstring vl_bs := substr(vl_cs, 3,5)
if(vl_bs!='00110'H){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
//semantic error (before compile time)
//testcase tc_predef_substring_hexstring7() runs on CT {
// const hexstring vl_cs := '00100110'H;
// const hexstring vl_bs := substr(vl_cs, 3, 6)
// setverdict(fail);
//}
//runtime error
testcase tc_predef_substring_hexstring8() runs on CT {
var hexstring vl_cs := '00100110'H;
@try {
var hexstring vl_bs := substr(vl_cs, 3,6)
setverdict(fail,"DTE expected");
}
@catch(e){
setverdict(pass);
}
}
//semantic error (before compile time)
//testcase tc_predef_substring_hexstring9() runs on CT {
// const hexstring vl_cs := '00100110'H;
// const hexstring vl_bs := substr(vl_cs, 9, 0)
// setverdict(fail);
//}
//runtime error
testcase tc_predef_substring_hexstring10() runs on CT {
var hexstring vl_cs := '00100110'H;
@try {
var hexstring vl_bs := substr(vl_cs, 9,0)
setverdict(fail,"DTE expected");
}
@catch(e){
setverdict(pass);
}
}
//--- octetstring ---
//compile time
testcase tc_predef_substring_octetstring1() runs on CT {
const octetstring vl_cs := ''O;
const octetstring vl_bs := substr(vl_cs, 0,0)
if(vl_bs!=''O){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_octetstring2() runs on CT {
var octetstring vl_cs := ''O;
var octetstring vl_bs := substr(vl_cs, 0,0);
log(vl_bs);
if( vl_bs!=''O){
setverdict(fail);
}
setverdict(pass);
}
testcase tc_predef_substring_octetstring3() runs on CT {
// const octetstring vl_cs := ''O;
const octetstring vl_bs := substr('00100110'O, 1, 2)
if(vl_bs!='1001'O){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_octetstring4() runs on CT {
var octetstring vl_cs := '00100110'O;
var octetstring vl_bs := substr(vl_cs, 1,2)
if(vl_bs!='1001'O){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_octetstring5() runs on CT {
const octetstring vl_cs := '00100110'O;
const octetstring vl_bs := substr(vl_cs, 1,3)
if(vl_bs!='100110'O){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_octetstring6() runs on CT {
var octetstring vl_cs := '00100110'O;
var octetstring vl_bs := substr(vl_cs, 1,3)
if(vl_bs!='100110'O){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
//semantic error (before compile time)
//testcase tc_predef_substring_octetstring7() runs on CT {
// const octetstring vl_cs := '00100110'O;
// const octetstring vl_bs := substr(vl_cs,1,4)
// setverdict(fail);
//}
//runtime error
testcase tc_predef_substring_octetstring8() runs on CT {
var octetstring vl_cs := '01020304'O;
@try {
var octetstring vl_bs := substr(vl_cs,1,4)
setverdict(fail,"DTE expected");
}
@catch(e){
setverdict(pass);
}
}
//semantic error (before compile time)
//testcase tc_predef_substring_octetstring9() runs on CT {
// const octetstring vl_cs := '00100110'O;
// const octetstring vl_bs := substr(vl_cs, 5, 0)
// setverdict(fail);
//}
//runtime error
testcase tc_predef_substring_octetstring10() runs on CT {
var octetstring vl_cs := '00100110'O;
@try {
var octetstring vl_bs := substr(vl_cs, 5,0)
setverdict(fail,"DTE expected");
}
@catch(e){
setverdict(pass);
}
}
//---charstring---
testcase tc_predef_substring_charstring1() runs on CT {
const charstring vl_cs := "";
const charstring vl_bs := substr(vl_cs, 0,0)
if(vl_bs!=""){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_charstring2() runs on CT {
var charstring vl_cs := "";
var charstring vl_bs := substr(vl_cs, 0,0);
log(vl_bs);
if( vl_bs!=""){
setverdict(fail);
}
setverdict(pass);
}
testcase tc_predef_substring_charstring3() runs on CT {
// const charstring vl_cs := "";
const charstring vl_bs := substr("00100110", 3, 4)
if(vl_bs!="0011"){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_charstring4() runs on CT {
var charstring vl_cs := "00100110";
var charstring vl_bs := substr(vl_cs, 3,4)
if(vl_bs!="0011"){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_charstring5() runs on CT {
const charstring vl_cs := "00100110";
const charstring vl_bs := substr(vl_cs, 3, 5)
if(vl_bs!="00110"){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_charstring6() runs on CT {
var charstring vl_cs := "00100110";
var charstring vl_bs := substr(vl_cs, 3,5)
if(vl_bs!="00110"){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
//semantic error (before compile time)
//testcase tc_predef_substring_charstring7() runs on CT {
// const charstring vl_cs := "00100110";
// const charstring vl_bs := substr(vl_cs, 3, 6)
// setverdict(fail);
//}
//runtime error
testcase tc_predef_substring_charstring8() runs on CT {
var charstring vl_cs := "00100110";
@try {
var charstring vl_bs := substr(vl_cs, 3,6)
setverdict(fail,"DTE expected");
}
@catch(e){
setverdict(pass);
}
}
//semantic error (before compile time)
//testcase tc_predef_substring_charstring9() runs on CT {
// const charstring vl_cs := "00100110";
// const charstring vl_bs := substr(vl_cs, 9, 0)
// setverdict(fail);
//}
//runtime error
testcase tc_predef_substring_charstring10() runs on CT {
var charstring vl_cs := "00100110";
@try {
var charstring vl_bs := substr(vl_cs, 9,0)
setverdict(fail,"DTE expected");
}
@catch(e){
setverdict(pass);
}
}
//---RoI---
// Semantic analyzer error
//testcase tc_predef_substring_RoI1() runs on CT {
// const RoI vl_cs := {};
// const RoI vl_bs := substr(vl_cs, 0,0)
// if(vl_bs!={}){
// setverdict(fail);
// }
// log(vl_bs);
// setverdict(pass);
//}
testcase tc_predef_substring_RoI2() runs on CT {
var RoI vl_cs := {};
var RoI vl_bs := substr(vl_cs, 0,0);
log(vl_bs);
if( vl_bs!={}){
setverdict(fail);
}
setverdict(pass);
}
testcase tc_predef_substring_RoI3() runs on CT {
const RoI vl_cs := {0,1,2,3,4,5,6,7};
const RoI vl_bs := substr(vl_cs, 3, 4)
if(vl_bs!={3,4,5,6}){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_RoI4() runs on CT {
var RoI vl_cs := {0,1,2,3,4,5,6,7};
var RoI vl_bs := substr(vl_cs, 3,4)
if(vl_bs!={3,4,5,6}){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_RoI5() runs on CT {
const RoI vl_cs := {0,1,2,3,4,5,6,7};
const RoI vl_bs := substr(vl_cs, 3, 5)
if(vl_bs!={3,4,5,6,7}){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_RoI6() runs on CT {
var RoI vl_cs := {0,1,2,3,4,5,6,7};
var RoI vl_bs := substr(vl_cs, 3,5)
if(vl_bs!={3,4,5,6,7}){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_RoI6a() runs on CT {
const RoI vl_cs := {0,1,2,3,4,5,6,7};
const RoI vl_bs := substr(vl_cs, 8,0)
if(vl_bs!={}){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_RoI6b() runs on CT {
var RoI vl_cs := {0,1,2,3,4,5,6,7};
var RoI vl_bs := substr(vl_cs, 8,0)
if(vl_bs!={}){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
//semantic error (before compile time)
//testcase tc_predef_substring_RoI7() runs on CT {
// const RoI vl_cs := {0,1,2,3,4,5,6,7};
// const RoI vl_bs := substr(vl_cs, 3, 6)
// setverdict(fail);
//}
//runtime error
testcase tc_predef_substring_RoI8() runs on CT {
var RoI vl_cs := {0,1,2,3,4,5,6,7};
@try {
var RoI vl_bs := substr(vl_cs, 3,6)
setverdict(fail,"DTE expected");
}
@catch(e){
setverdict(pass);
}
}
//semantic error (before compile time)
//testcase tc_predef_substring_RoI9() runs on CT {
// const RoI vl_cs := {0,1,2,3,4,5,6,7};
// const RoI vl_bs := substr(vl_cs, 9, 0)
// setverdict(fail);
//}
//runtime error
testcase tc_predef_substring_RoI10() runs on CT {
var RoI vl_cs := {0,1,2,3,4,5,6,7};
@try {
var RoI vl_bs := substr(vl_cs, 9,0)
setverdict(fail,"DTE expected");
}
@catch(e){
setverdict(pass);
}
}
//----SoI---
//---RoI---
// Semantic analyzer error
//testcase tc_predef_substring_SoI1() runs on CT {
// const SoI vl_cs := {};
// const SoI vl_bs := substr(vl_cs, 0,0)
// if(vl_bs!={}){
// setverdict(fail);
// }
// log(vl_bs);
// setverdict(pass);
//}
testcase tc_predef_substring_SoI2() runs on CT {
var SoI vl_cs := {};
var SoI vl_bs := substr(vl_cs, 0,0);
log(vl_bs);
if( vl_bs!={}){
setverdict(fail);
}
setverdict(pass);
}
testcase tc_predef_substring_SoI3() runs on CT {
const SoI vl_cs := {0,1,2,3,4,5,6,7};
const SoI vl_bs := substr(vl_cs, 3, 4)
if(vl_bs!={3,4,5,6}){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_SoI4() runs on CT {
var SoI vl_cs := {0,1,2,3,4,5,6,7};
var SoI vl_bs := substr(vl_cs, 3,4)
if(vl_bs!={3,4,5,6}){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_SoI5() runs on CT {
const SoI vl_cs := {0,1,2,3,4,5,6,7};
const SoI vl_bs := substr(vl_cs, 3, 5)
if(vl_bs!={3,4,5,6,7}){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_SoI6() runs on CT {
var SoI vl_cs := {0,1,2,3,4,5,6,7};
var SoI vl_bs := substr(vl_cs, 3,5)
if(vl_bs!={3,4,5,6,7}){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_SoI6a() runs on CT {
const SoI vl_cs := {0,1,2,3,4,5,6,7};
const SoI vl_bs := substr(vl_cs, 8,0)
if(vl_bs!={}){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
testcase tc_predef_substring_SoI6b() runs on CT {
var SoI vl_cs := {0,1,2,3,4,5,6,7};
var SoI vl_bs := substr(vl_cs, 8,0)
if(vl_bs!={}){
setverdict(fail);
}
log(vl_bs);
setverdict(pass);
}
//semantic error (before compile time)
//testcase tc_predef_substring_SoI7() runs on CT {
// const SoI vl_cs := {0,1,2,3,4,5,6,7};
// const SoI vl_bs := substr(vl_cs, 3, 6)
// setverdict(fail);
//}
//runtime error
testcase tc_predef_substring_SoI8() runs on CT {
var SoI vl_cs := {0,1,2,3,4,5,6,7};
@try {
var SoI vl_bs := substr(vl_cs, 3,6)
setverdict(fail,"DTE expected");
}
@catch(e){
setverdict(pass);
}
}
//semantic error (before compile time)
//testcase tc_predef_substring_SoI9() runs on CT {
// const SoI vl_cs := {0,1,2,3,4,5,6,7};
// const SoI vl_bs := substr(vl_cs, 9, 0)
// setverdict(fail);
//}
//runtime error
testcase tc_predef_substring_SoI10() runs on CT {
var SoI vl_cs := {0,1,2,3,4,5,6,7};
@try {
var SoI vl_bs := substr(vl_cs, 9,0)
setverdict(fail,"DTE expected");
}
@catch(e){
setverdict(pass);
}
}
//unichar2char
//unichar2int
control{
execute(tc_predef_str2float_empty());
execute(tc_predef_str2float_empty2());
execute( tc_predef_str2float_good1());
execute( tc_predef_str2float_good2());
execute( tc_predef_str2float_good2a());
execute( tc_predef_str2float_good2b());
execute( tc_predef_str2float_good2c());
execute( tc_predef_str2float_good2d());
execute( tc_predef_str2float_good3());
execute( tc_predef_str2float_good3b());
execute( tc_predef_str2float_good4());
execute( tc_predef_str2float_good4b());
execute( tc_predef_str2float_good4c());
execute( tc_predef_str2float_good5());
execute(tc_predef_str2float_bad1());
// execute(tc_predef_str2float_bad1b()); //semantic error
execute(tc_predef_str2float_bad2());
execute(tc_predef_str2float_bad3());
execute(tc_predef_str2float_bad4());
execute( tc_predef_rnd());
execute( tc_predef_bit2hex1());
execute( tc_predef_bit2hex2());
execute(tc_predef_bit2hex_bitstr_element());
execute(tc_predef_bit2oct1());
execute(tc_predef_bit2oct2());
execute(tc_predef_bit2oct_bitstr_element())
execute(tc_predef_bit2int_good());
execute(tc_predef_bit2int_good_with_space());
execute(tc_predef_bit2int_good_long1());
execute(tc_predef_bit2int_good_long2());
execute(tc_predef_bit2int_good_long3());
execute(tc_predef_bit2int_good_long4());
execute(tc_predef_bit2int_good_long5());
execute(tc_predef_bit2int_bitstr_element());
// execute(tc_predef_bit2int_good_with_whitespace());
execute(tc_predef_bit2int_good_empty());
execute(tc_predef_bit2oct_good());
execute(tc_predef_bit2oct_good_with_space());
execute(tc_predef_bit2oct_bitstr_element());
execute(tc_predef_bit2str_good());
execute(tc_predef_bit2str_good_with_space());
execute(tc_predef_bit2str_good_empty());
execute(tc_predef_bit2str_bitstr_element());
execute(tc_predef_char2int_good());
execute(tc_predef_char2int_good_charstring_element());
execute(tc_predef_char2int_bad1());
execute(tc_predef_char2int_bad2());
execute(tc_predef_char2int_bad3());
execute(tc_predef_char2int_bad4());
execute(tc_predef_char2oct_good1());
execute(tc_predef_char2oct_charstring_element());
execute(tc_predef_char2oct_good_empty());
execute(tc_predef_float2int_good1());
execute(tc_predef_float2int_bad1());
execute(tc_predef_float2str_good0());
execute(tc_predef_float2str_good1());
execute(tc_predef_float2str_good2());
execute(tc_predef_float2str_good3());
execute(tc_predef_float2str_good4());
execute(tc_predef_float2str_good5());
execute(tc_predef_float2str_good6());
execute(tc_predef_float2str_good7());
execute(tc_predef_float2str_good8());
execute(tc_predef_float2str_good9());
execute(tc_predef_float2str_good10());
execute(tc_predef_float2str_good11());
execute(tc_predef_float2str_good12());
execute(tc_predef_float2str_good13());
execute(tc_predef_float2str_good14());
execute(tc_predef_float2str_good15());
execute(tc_predef_float2str_good16());
execute(tc_predef_hex2bit_empty1());
execute(tc_predef_hex2bit_empty2());
execute(tc_predef_hex2bit_unbound());
execute(tc_predef_hex2bit_good1());
execute(tc_predef_hex2bit_good2());
execute(tc_predef_hex2bit_good20());
execute(tc_predef_hex2bit_hexstr_element());
execute(tc_predef_hex2int_unbound());
execute(tc_predef_hex2int_empty());
execute(tc_predef_hex2int_good1());
execute(tc_predef_hex2int_good2());
execute(tc_predef_hex2int_good3());
execute(tc_predef_hex2int_hexstr_element());
execute(tc_predef_hex2oct_empty1());
execute(tc_predef_hex2oct_empty2());
execute(tc_predef_hex2oct_unbound());
execute(tc_predef_hex2oct_good1());
execute(tc_predef_hex2oct_good2());
execute(tc_predef_hex2oct_good3());
execute(tc_predef_hex2oct_good4());
execute(tc_predef_hex2oct_good5());
execute(tc_predef_hex2oct_good6());
execute(tc_predef_hex2oct_good7());
execute(tc_predef_hex2oct_hexstr_element());
execute(tc_predef_hex2str_empty1());
execute(tc_predef_hex2str_unbound());
execute(tc_predef_hex2str_good1());
execute(tc_predef_hex2str_good2());
execute(tc_predef_hex2str_good3());
execute(tc_predef_hex2str_good4());
execute(tc_predef_hex2str_good5());
execute(tc_predef_hex2str_good6());
execute(tc_predef_hex2str_good7());
execute(tc_predef_hex2str_hexstring_element());
execute(tc_predef_int2bit_unbound());
execute(tc_predef_int2bit_wrongLength());
execute(tc_predef_int2bit_negLength());
execute(tc_predef_int2bit_good1());
execute(tc_predef_int2bit_good2());
execute(tc_predef_int2bit_good3());
execute(tc_predef_int2char_good());
execute(tc_predef_int2char_list());
execute(tc_predef_int2char_bad1());
execute(tc_predef_int2char_bad2());
execute(tc_predef_int2float_good1());
execute(tc_predef_int2float_good2());
execute(tc_predef_int2hex_good1());
execute(tc_predef_int2hex_bad1());
execute(tc_predef_int2hex_bad2());
execute(tc_predef_int2hex_bad3());
execute(tc_predef_int2oct_good1());
execute(tc_predef_int2oct_good1a());
execute(tc_predef_int2oct_good2());
execute(tc_predef_int2oct_good3());
execute(tc_predef_int2oct_bad1());
execute(tc_predef_int2oct_bad2());
execute(tc_predef_int2oct_bad3());
execute(tc_predef_int2oct_bad4());
execute(tc_predef_int2str_good1());
execute(tc_predef_int2str_good2());
execute(tc_predef_int2unichar_good1());
execute(tc_predef_int2unichar_good2());
execute(tc_predef_int2unichar_bad1());
execute(tc_predef_int2unichar_bad2());
execute(tc_predef_int2unichar_bad3());
execute(tc_predef_oct2bit_good());
execute(tc_predef_oct2char_good1());
execute(tc_predef_oct2char_good2());
execute(tc_predef_oct2char_bad1());
execute(tc_predef_oct2char_bad2());
execute(tc_predef_oct2char_bad3());
execute(tc_predef_oct2char_octetstr_elem());
execute(tc_predef_oct2char_octetstr_elem_bad());
execute(tc_predef_oct2hex_good1());
execute(tc_predef_oct2int_good1());
execute(tc_predef_oct2int_good1a());
execute(tc_predef_oct2int_good1b());
execute(tc_predef_oct2int_good2());
execute(tc_predef_oct2int_empty());
execute(tc_predef_oct2str_good1());
execute(tc_predef_oct2str_good2());
execute(tc_predef_oct2str_octetstring_element());
execute(tc_predef_replace_bitstring_1());
execute(tc_predef_replace_bitstring_1a());
execute(tc_predef_replace_bitstring_1b());
execute(tc_predef_replace_bitstring_2());
execute(tc_predef_replace_bitstring_2a());
execute(tc_predef_replace_bitstring_3());
execute(tc_predef_replace_bitstring_4());
execute(tc_predef_replace_bitstring_5());
execute(tc_predef_replace_bitstring_6());
execute(tc_predef_replace_bitstring_7());
execute(tc_predef_replace_bitstring_8());
execute(tc_predef_replace_bitstring_9());
// execute(tc_predef_replace_bitstring_10());
execute(tc_predef_replace_bitstring_11());
// execute(tc_predef_replace_bitstring_12());
execute(tc_predef_replace_bitstring_14_bad());
execute(tc_predef_replace_bitstring_16_bad());
execute(tc_predef_replace_bitstring_18_bad());
execute(tc_predef_replace_bitstring_19_bad());
execute(tc_predef_replace_bitstring_20_bad());
execute(tc_predef_replace_bitstring_21_bad());
execute(tc_predef_replace_bitstring_22_bad());
execute(tc_predef_replace_bitstring_23());
execute(tc_predef_replace_bitstring_24());
//===
execute(tc_predef_replace_hexstring_1());
execute(tc_predef_replace_hexstring_1a());
execute(tc_predef_replace_hexstring_1b());
execute(tc_predef_replace_hexstring_2());
execute(tc_predef_replace_hexstring_2a());
execute(tc_predef_replace_hexstring_3());
execute(tc_predef_replace_hexstring_4());
execute(tc_predef_replace_hexstring_5());
execute(tc_predef_replace_hexstring_6());
execute(tc_predef_replace_hexstring_7());
execute(tc_predef_replace_hexstring_8());
execute(tc_predef_replace_hexstring_9());
execute(tc_predef_replace_hexstring_10());
execute(tc_predef_replace_hexstring_11());
execute(tc_predef_replace_hexstring_12());
execute(tc_predef_replace_hexstring_14_bad());
execute(tc_predef_replace_hexstring_16_bad());
execute(tc_predef_replace_hexstring_18_bad());
execute(tc_predef_replace_hexstring_19());
execute(tc_predef_replace_hexstring_20());
execute(tc_predef_replace_hexstring_21());
execute(tc_predef_replace_hexstring_22());
execute(tc_predef_replace_hexstring_23());
execute(tc_predef_replace_hexstring_24());
execute(tc_predef_replace_hexstring_25());
execute(tc_predef_replace_hexstring_26());
//===
execute(tc_predef_replace_octetstring_1());
execute(tc_predef_replace_octetstring_1a());
execute(tc_predef_replace_octetstring_1b());
execute(tc_predef_replace_octetstring_2());
execute(tc_predef_replace_octetstring_2a());
execute(tc_predef_replace_octetstring_3());
execute(tc_predef_replace_octetstring_4());
execute(tc_predef_replace_octetstring_5());
execute(tc_predef_replace_octetstring_6());
execute(tc_predef_replace_octetstring_7());
execute(tc_predef_replace_octetstring_8());
execute(tc_predef_replace_octetstring_9());
execute(tc_predef_replace_octetstring_10());
execute(tc_predef_replace_octetstring_11());
execute(tc_predef_replace_octetstring_12());
execute(tc_predef_replace_octetstring_14_bad());
execute(tc_predef_replace_octetstring_16_bad());
execute(tc_predef_replace_octetstring_18_bad());
execute(tc_predef_replace_octetstring_19_bad());
execute(tc_predef_replace_octetstring_20_bad());
execute(tc_predef_replace_octetstring_21_bad());
execute(tc_predef_replace_octetstring_22_bad());
execute(tc_predef_replace_octetstring_23_bad());
execute(tc_predef_replace_octetstring_24_bad());
execute(tc_predef_replace_octetstring_25());
execute(tc_predef_replace_octetstring_26());
//===
execute(tc_predef_replace_charstring_1());
execute(tc_predef_replace_charstring_1a());
execute(tc_predef_replace_charstring_1b());
execute(tc_predef_replace_charstring_2());
execute(tc_predef_replace_charstring_2a());
execute(tc_predef_replace_charstring_3());
execute(tc_predef_replace_charstring_4());
execute(tc_predef_replace_charstring_5());
execute(tc_predef_replace_charstring_6());
execute(tc_predef_replace_charstring_7());
execute(tc_predef_replace_charstring_8());
execute(tc_predef_replace_charstring_9());
execute(tc_predef_replace_charstring_10());
execute(tc_predef_replace_charstring_11());
execute(tc_predef_replace_charstring_12());
execute( tc_predef_replace_charstring_14_bad());
execute( tc_predef_replace_charstring_16_bad());
execute( tc_predef_replace_charstring_18_bad());
execute(tc_predef_replace_RoI_1());
execute(tc_predef_replace_RoI_1a());
execute(tc_predef_replace_RoI_1b());
execute(tc_predef_replace_RoI_2());
execute(tc_predef_replace_RoI_2a());
execute(tc_predef_replace_RoI_3());
execute(tc_predef_replace_RoI_4());
execute(tc_predef_replace_RoI_5());
execute(tc_predef_replace_RoI_6());
execute(tc_predef_replace_RoI_7());
execute(tc_predef_replace_RoI_8());
execute(tc_predef_replace_RoI_9());
execute(tc_predef_replace_RoI_10());
execute(tc_predef_replace_RoI_11());
execute(tc_predef_replace_RoI_12());
execute( tc_predef_replace_RoI_14_bad());
execute( tc_predef_replace_RoI_16_bad());
execute( tc_predef_replace_RoI_18_bad());
execute(tc_predef_str2bit_good1());
execute(tc_predef_str2bit_good2());
execute(tc_predef_str2bit_good2a());
execute(tc_predef_str2bit_good3());
execute(tc_predef_str2hex_good1());
execute(tc_predef_str2hex_good2());
execute(tc_predef_str2hex_good2a());
execute(tc_predef_str2hex_good3());
execute(tc_predef_str2int_good1());
execute(tc_predef_str2int_good2());
execute(tc_predef_str2oct_good1());
execute(tc_predef_str2oct_good2());
execute(tc_predef_str2oct_good2a());
execute(tc_predef_substring_bitstring1());
execute(tc_predef_substring_bitstring2());
execute(tc_predef_substring_bitstring3());
execute(tc_predef_substring_bitstring4());
execute(tc_predef_substring_bitstring5());
execute(tc_predef_substring_bitstring6());
// execute(tc_predef_substring_bitstring7()); //semantic error
execute(tc_predef_substring_bitstring8());
// execute(tc_predef_substring_bitstring9()); //semantic error
execute(tc_predef_substring_bitstring10());
execute(tc_predef_substring_hexstring1());
execute(tc_predef_substring_hexstring2());
execute(tc_predef_substring_hexstring3());
execute(tc_predef_substring_hexstring4());
execute(tc_predef_substring_hexstring5());
execute(tc_predef_substring_hexstring6());
// execute(tc_predef_substring_hexstring7()); //semantic error
execute(tc_predef_substring_hexstring8());
// execute(tc_predef_substring_hexstring9()); //semantic error
execute(tc_predef_substring_hexstring10());
execute(tc_predef_substring_octetstring1());
execute(tc_predef_substring_octetstring2());
execute(tc_predef_substring_octetstring3());
execute(tc_predef_substring_octetstring4());
execute(tc_predef_substring_octetstring5());
execute(tc_predef_substring_octetstring6());
//execute(tc_predef_substring_octetstring7()); //semantic error
execute(tc_predef_substring_octetstring8());
// execute(tc_predef_substring_octetstring9()); //semantic error
execute(tc_predef_substring_octetstring10());
execute(tc_predef_substring_charstring1());
execute(tc_predef_substring_charstring2());
execute(tc_predef_substring_charstring3());
execute(tc_predef_substring_charstring4());
execute(tc_predef_substring_charstring5());
execute(tc_predef_substring_charstring6());
// execute(tc_predef_substring_charstring7()); //semantic error
execute(tc_predef_substring_charstring8());
// execute(tc_predef_substring_charstring9()); //semantic error
execute(tc_predef_substring_charstring10());
// execute(tc_predef_substring_RoI1());//semantic error
execute(tc_predef_substring_RoI2());
execute(tc_predef_substring_RoI3());
execute(tc_predef_substring_RoI4());
execute(tc_predef_substring_RoI5());
execute(tc_predef_substring_RoI6());
execute(tc_predef_substring_RoI6a());
execute(tc_predef_substring_RoI6b());
// execute(tc_predef_substring_RoI7()); //semantic error
execute(tc_predef_substring_RoI8());
// execute(tc_predef_substring_RoI9()); //semantic error
execute(tc_predef_substring_RoI10());
// execute(tc_predef_substring_SoI1()); //semantic error
execute(tc_predef_substring_SoI2());
execute(tc_predef_substring_SoI3());
execute(tc_predef_substring_SoI4());
execute(tc_predef_substring_SoI5());
execute(tc_predef_substring_SoI6());
execute(tc_predef_substring_SoI6a());
execute(tc_predef_substring_SoI6b());
// execute(tc_predef_substring_SoI7()); //semantic error
execute(tc_predef_substring_SoI8());
// execute(tc_predef_substring_SoI9()); //semantic error
execute(tc_predef_substring_SoI10());
}
}