diff --git a/regression_test/Makefile b/regression_test/Makefile
index 8874e711f4ae037520489d667eeeca4153bd0703..a74f83ec160fd1d7413a2d2daf2c446762b38f92 100644
--- a/regression_test/Makefile
+++ b/regression_test/Makefile
@@ -49,7 +49,7 @@ all_from lazyEval tryCatch text2ttcn json ttcn2json profiler templateOmit \
customEncoding makefilegen uidChars checkstate hostid templateIstemplatekind \
selectUnion templateExclusiveRange any_from templatePatternRef indexWithRecofArray \
connectMapOperTest fuzzy portTranslation ischosen OER functionSubref done \
-nondeterministicDefaultParam
+nondeterministicDefaultParam predefFunction2
ifdef DYN
DIRS += loggerplugin junitlogger
diff --git a/regression_test/predefFunction2/Makefile b/regression_test/predefFunction2/Makefile
new file mode 100755
index 0000000000000000000000000000000000000000..4d1d25461b142afc851050d757760291e0c91ed1
--- /dev/null
+++ b/regression_test/predefFunction2/Makefile
@@ -0,0 +1,56 @@
+##############################################################################
+# Copyright (c) 2000-2017 Ericsson Telecom AB
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+# Balasko, Jeno
+#
+##############################################################################
+TOPDIR := ..
+include $(TOPDIR)/Makefile.regression
+
+.SUFFIXES: .ttcn .hh
+.PHONY: all clean dep run
+
+TTCN3_LIB = ttcn3$(RT2_SUFFIX)$(DYNAMIC_SUFFIX)
+
+TTCN3_MODULES = predefFunctTest.ttcn
+
+GENERATED_SOURCES = $(TTCN3_MODULES:.ttcn=.cc)
+GENERATED_HEADERS = $(GENERATED_SOURCES:.cc=.hh)
+ifdef CODE_SPLIT
+GENERATED_SOURCES := $(foreach file, $(GENERATED_SOURCES:.cc=), $(addprefix $(file), .cc _seq.cc _set.cc _seqof.cc _setof.cc _union.cc))
+else ifdef SPLIT_TO_SLICES
+POSTFIXES := $(foreach file, $(SPLIT_TO_SLICES), $(addsuffix $(file), _part_))
+POSTFIXES := $(foreach file, $(POSTFIXES), $(addprefix $(file), .cc))
+GENERATED_SOURCES2 := $(foreach file, $(GENERATED_SOURCES:.cc=), $(addprefix $(file), $(POSTFIXES)))
+GENERATED_SOURCES += $(GENERATED_SOURCES2)
+endif
+
+OBJECTS = $(GENERATED_SOURCES:.cc=.o)
+
+TARGET = predefFunctTest$(EXESUFFIX)
+
+all: $(TARGET)
+
+$(TARGET): $(GENERATED_SOURCES) $(USER_SOURCES)
+ $(CXX) $(CPPFLAGS) $(CXXFLAGS) $(LDFLAGS) -o $@ $^ -L$(TTCN3_DIR)/lib -l$(TTCN3_LIB) -L$(OPENSSL_DIR)/lib -lcrypto $($(PLATFORM)_LIBS)
+
+.ttcn.cc .ttcn.hh:
+ $(TTCN3_COMPILER) $<
+
+clean distclean:
+ -rm -f $(TARGET) $(OBJECTS) $(GENERATED_HEADERS) \
+ $(GENERATED_SOURCES) *.log Makefile.bak
+
+dep: $(GENERATED_SOURCES)
+ makedepend $(CPPFLAGS) $(GENERATED_SOURCES)
+
+run: $(TARGET) config.cfg
+ ./$^
+
+.NOTPARALLEL:
+
diff --git a/regression_test/predefFunction2/config.cfg b/regression_test/predefFunction2/config.cfg
new file mode 100755
index 0000000000000000000000000000000000000000..1f3853943400d2bb26fa7711255d8120260641aa
--- /dev/null
+++ b/regression_test/predefFunction2/config.cfg
@@ -0,0 +1,19 @@
+###############################################################################
+# Copyright (c) 2000-2017 Ericsson Telecom AB
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+#
+# Contributors:
+# Balasko, Jeno
+# Szabo, Janos Zoltan – initial implementation
+#
+###############################################################################
+[MODULE_PARAMETERS]
+[LOGGING]
+Logfile := "predefFunctTest.log"
+FileMask := LOG_ALL
+ConsoleMask := TTCN_WARNING | TTCN_ERROR | TTCN_TESTCASE | TTCN_STATISTICS
+[EXECUTE]
+predefFunctTest.control
diff --git a/regression_test/predefFunction2/predefFunctTest.ttcn b/regression_test/predefFunction2/predefFunctTest.ttcn
new file mode 100755
index 0000000000000000000000000000000000000000..fe7f215905090910d8d6cafa05b024294ecf3216
--- /dev/null
+++ b/regression_test/predefFunction2/predefFunctTest.ttcn
@@ -0,0 +1,3951 @@
+//These tests are supplementary testcases to the existing regression test
+//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 bitstring vl_bs := '0001'B;
+ var hexstring vl_hs := bit2hex( c_bs_empty1 & vl_bs & vl_bs[1]);
+ if (vl_hs == '02'H) {
+ setverdict(pass)
+ } else {
+ setverdict(fail, "expected '02'H got:", vl_hs);
+ }
+}
+
+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);
+ }
+}
+
+
+testcase tc_predef_bit2oct0010() runs on CT {
+ var bitstring vl_bs := '0010'B;
+ var octetstring vl_os := bit2oct(vl_bs);
+ if (vl_os == '02'O) {
+ setverdict(pass)
+ } else {
+ setverdict(fail, "expected '02'H got:", vl_os);
+ }
+}
+
+testcase tc_predef_bit2oct00010() runs on CT {
+ var bitstring vl_bs := '00010'B;
+ var octetstring vl_os := bit2oct(vl_bs);
+ if (vl_os == '02'O) {
+ setverdict(pass)
+ } else {
+ setverdict(fail, "expected '02'O got:", vl_os);
+ }
+}
+testcase tc_predef_bit2oct1() runs on CT {
+ var bitstring vl_bs := '0001'B;
+ var octetstring vl_os := bit2oct( c_bs_empty1 & vl_bs & vl_bs[1]);
+ if (vl_os == '02'O) {
+ setverdict(pass)
+ } else {
+ setverdict(fail, "expected '02'O got:", vl_os);
+ }
+}
+
+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);
+ }
+}
+//====== 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));
+}
+
+//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
+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);
+}
+
+//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_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")
+ }
+}
+
+//char2oct
+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_good2() runs on CT {
+ var RoCS vl_cslist := {"abzAZ019 !\"\\~\b\t\n\f\r\'\"*?" }
+ var RoOS vl_expectedList := { '61627A415A3031392021225C7E08090A0C0D27222A3F'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_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);
+}
+//======= 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);
+ }
+}
+
+testcase tc_predef_hex2bit_good21() 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_good20() runs on CT {
+ var hexstring vl_hs :='ABBA9'H
+ if(hex2int(vl_hs)==703401){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+//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]))
+ }
+}
+
+testcase tc_predef_hex2oct_good1_bug() runs on CT{
+ if(hex2oct('4'H)=='04'O){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+testcase tc_predef_hex2oct_good2_bug() runs on CT{
+ if(hex2oct('00FF'H)=='00FF'O){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_hex2oct_good3_bug() runs on CT{
+ if(hex2oct('0FF'H)=='00FF'O){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+//padding expected
+testcase tc_predef_hex2oct_good4_bug() runs on CT{
+ var hexstring vl_hs := '0FF'H
+ if(hex2oct(vl_hs)=='00FF'O){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_hex2oct_good20() runs on CT {
+ var hexstring vl_hs :='ABBA9'H
+ if(hex2oct(vl_hs)=='0ABBA9'O){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_hex2oct_good21() 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=============
+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");
+ }
+ }@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:",hex2oct(vl_hexaValues[i]))
+ }
+}
+
+testcase tc_predef_hex2str_good1_bug() runs on CT{
+ if(hex2str('4'H)=="4"){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+testcase tc_predef_hex2str_good2_bug() runs on CT{
+ if(hex2str('00FF'H)=="00FF"){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_hex2str_good3_bug() runs on CT{
+ if(hex2str('0FF'H)=="0FF"){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+//padding expected
+testcase tc_predef_hex2str_good4_bug() runs on CT{
+ var hexstring vl_hs := '0FF'H
+ if(hex2str(vl_hs)=="0FF"){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_hex2str_good20() runs on CT {
+ var hexstring vl_hs :='ABBA9'H
+ if(hex2str(vl_hs)=="ABBA9"){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_hex2str_good21() 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_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")
+ }
+}
+//==== 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 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,''O
+ }
+ var RoCS vl_cslist := {
+ char(0, 0, 0, 0),char(0, 0, 0, 1),char(0, 0, 0, 0) & char(0, 0, 0, 1),char(0, 0, 0, 2),char(0, 0, 0, 3),
+ char(0, 0, 0, 4),char(0, 0, 0, 5),char(0, 0, 0, 6),char(0, 0, 0, 7),char(0, 0, 0, 8),
+ "\b","\t","\n",char(0, 0, 0, 16),char(0, 0, 0, 17),
+ char(0, 0, 0, 0)& char(0, 0, 0, 0)& char(0, 0, 0, 17),
+ char(0, 0, 0, 26), char(0,0,0,127), "01239:;~`",""
+ }
+ 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]));
+ }
+ 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")
+ }
+}
+//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
+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);
+}
+
+//================================================
+//============ 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")
+ }
+}
+
+//*********** 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")
+ }
+}
+
+//*********** 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_bs := replace('0000 1111'O,vl_beginning,vl_len,''O);
+ if(vl_bs != '00 1111'O){
+ setverdict(fail, "expected '001111'O got:", vl_bs);
+ } 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_bs := replace('0000 1111'O,vl_beginning,vl_len,''O);
+ if(vl_bs != '00 1111'O){
+ setverdict(fail, "expected '001111'O got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+// remove 2 chars from the beginnining, run time
+testcase tc_predef_replace_octetstring_2() runs on CT {
+ var octetstring vl_bs0 := '0000 1111'O
+ var octetstring vl_bs := replace(vl_bs0,0,1,''O);
+ if(vl_bs != '00 1111'O){
+ setverdict(fail, "expected '001111'O got:", vl_bs);
+ } 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_bs0 := '0000 1111'O
+ var octetstring vl_bs := replace(vl_bs0,vl_beginning,vl_len,''O);
+ if(vl_bs != '00 1111'O){
+ setverdict(fail, "expected '001111'O got:", vl_bs);
+ } 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_bs := replace('0000 1111'O,0,1,'11'O);
+ if(vl_bs != '1100 1111'O){
+ setverdict(fail, "expected '11001111'O got:", vl_bs);
+ } 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_bs0 := '0000 1111'O
+ var octetstring vl_bs := replace(vl_bs0,0,1,'11'O);
+ if(vl_bs != '1100 1111'O){
+ setverdict(fail, "expected '11001111'O got:", vl_bs);
+ } 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_bs := replace('0000 1111'O,0,2,'11'O);
+ if(vl_bs != '11 1111'O){
+ setverdict(fail, "expected '111111'O got:", vl_bs);
+ } 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_bs0 := '0000 1111'O
+ var octetstring vl_bs := replace(vl_bs0,0,2,'11'O);
+ if(vl_bs != '11 1111'O){
+ setverdict(fail, "expected '111111'O got:", vl_bs);
+ } 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_bs := replace('0000 1111'O,0,2,'1111'O);
+ if(vl_bs != '1111 1111'O){
+ setverdict(fail, "expected '11111111'O got:", vl_bs);
+ } 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_bs0 := '0000 1111'O
+ var octetstring vl_bs := replace(vl_bs0,0,2,'1111'O);
+ if(vl_bs != '1111 1111'O){
+ setverdict(fail, "expected '11111111'O 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_octetstring_9() runs on CT {
+ var octetstring vl_bs := replace('0000 1111'O,1,2,'1111'O);
+ if(vl_bs != '00 1111 11'O){
+ setverdict(fail, "expected '00111111'O got:", vl_bs);
+ } 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_bs0 := '0000 1111'O
+ var octetstring vl_bs := replace(vl_bs0,1,2,'1111'O);
+ if(vl_bs != '00111111'O){
+ setverdict(fail, "expected '00111111'O got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// append 4 chars compile time
+testcase tc_predef_replace_octetstring_11() runs on CT {
+ var octetstring vl_bs := replace('0000 1111'O,4,0,'0011'O);
+ if(vl_bs != '0000 1111 0011'O){
+ setverdict(fail, "expected '000011110011'O got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// append 3 char runtime
+testcase tc_predef_replace_octetstring_12() runs on CT {
+ var octetstring vl_bs0 := '0000 1111'O
+ var octetstring vl_bs := replace(vl_bs0,4,0,'0011'O);
+ if(vl_bs != '0000 1111 0011'O){
+ setverdict(fail, "expected '000011110011'O 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_octetstring_13_bad() runs on CT {
+// var octetstring vl_bs := replace('0000 1111'O,8,1,'011'O);
+
+//}
+
+//too long index: 8+1
+testcase tc_predef_replace_octetstring_14_bad() runs on CT {
+ var octetstring vl_bs0 := '0000 1111'O
+ @try {
+ var octetstring vl_bs := replace(vl_bs0,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_bs := 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_bs := replace('0000 1111'O,3,-2,'0011'O);
+//}
+//testcase tc_predef_replace_octetstring_15b_bad() runs on CT {
+// var octetstring vl_bs := replace('0000 1111'O,3,-2,'11'O);
+//}
+
+//too long index: 7+2
+testcase tc_predef_replace_octetstring_16_bad() runs on CT {
+ var octetstring vl_bs0 := '0000 1111'O
+ @try {
+ var octetstring vl_bs := replace(vl_bs0,3,2,'0011'O);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+//too long index: 9+0
+testcase tc_predef_replace_octetstring_18_bad() runs on CT {
+ var octetstring vl_bs0 := '0000 1111'O
+ @try {
+ var octetstring vl_bs := replace(vl_bs0,5,0,'0011'O);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+
+//*********** 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 := '00100110'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_bit2oct0010());
+ execute(tc_predef_bit2oct00010());
+ execute(tc_predef_bit2oct1());
+ execute(tc_predef_bit2oct2());
+ 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_with_whitespace());
+ execute(tc_predef_bit2int_good_empty());
+ execute(tc_predef_bit2oct_good());
+ execute(tc_predef_bit2oct_good_with_space());
+ execute(tc_predef_bit2str_good());
+ execute(tc_predef_bit2str_good_with_space());
+ execute(tc_predef_bit2str_good_empty());
+ execute(tc_predef_char2int_good());
+ execute(tc_predef_char2int_bad1());
+ execute(tc_predef_char2int_bad2());
+ execute(tc_predef_char2oct_good1());
+ execute(tc_predef_char2oct_good2());
+ execute(tc_predef_char2oct_good_empty());
+ 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_good21());
+ execute(tc_predef_hex2int_unbound());
+ execute(tc_predef_hex2int_empty());
+ execute(tc_predef_hex2int_good1());
+ execute(tc_predef_hex2int_good2());
+ execute(tc_predef_hex2int_good20());
+ 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_bug());
+ execute(tc_predef_hex2oct_good4_bug());
+ execute(tc_predef_hex2oct_good20());
+
+ execute(tc_predef_hex2str_empty1());
+ execute(tc_predef_hex2str_unbound());
+ execute(tc_predef_hex2str_good1());
+ execute(tc_predef_hex2str_good2());
+ execute(tc_predef_hex2str_good1_bug());
+ execute(tc_predef_hex2str_good2_bug());
+ execute(tc_predef_hex2str_good3_bug());
+ execute(tc_predef_hex2str_good4_bug());
+ execute(tc_predef_hex2str_good20());
+ execute(tc_predef_hex2str_good21());
+
+ execute(tc_predef_int2bit_unbound());
+ execute(tc_predef_int2bit_wrongLength());
+ 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_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_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_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_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_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());
+}
+}
+