diff --git a/Regression_Test_java/single_bugs.cfg b/Regression_Test_java/single_bugs.cfg
index 2894a5d79731d442264be7d4af677b829541fc65..cd7e6b9401fe8b449d33034c24fe2faff4478a6b 100755
--- a/Regression_Test_java/single_bugs.cfg
+++ b/Regression_Test_java/single_bugs.cfg
@@ -35,8 +35,9 @@
#TvalueofSubref.control #the file excluded!!
#TfunctionSubref.tc_func_subref_parameter
#TpardTemplateSubref.control # 6 error
-
-
+predefFunctTest.tc_predef_oct2char_good1
+predefFunctTest.tc_predef_oct2char_good2
+predefFunctTest.tc_predef_oct2char_octetstr_elem
[LOGGING]
# In this section you can specify the name of the log file and the classes of events
# you want to log into the file or display on console (standard error).
diff --git a/Regression_Test_java/single_config.cfg b/Regression_Test_java/single_config.cfg
index 3281c7f887230494fe3f662bbf8acb1bcad673ae..a7921ab3bccb4387e5d62dffd10acb8ba5b1b3b6 100644
--- a/Regression_Test_java/single_config.cfg
+++ b/Regression_Test_java/single_config.cfg
@@ -16,7 +16,8 @@
#"src/cfgFile/ordered_include/oi_after_list1.cfg" #Error while setting parameter field 'tsp_c' to '0': Type mismatch: charstring value was expected instead of null.
#"src/cfgFile/testport_parameters/array_index.cfg" #compiled, not runnining, it shall be excluded anyway!!!
"src/ucharstrOper/config.cfg"
-"src/hexstrOper/config.cfg" #TODO: one testase is commented out (send())
+"src/hexstrOper/config.cfg" #TODO: one testase is commented out (send())
+"src/implicitOmit/config.cfg" #ok, 18 pass
[EXECUTE]
#==acceptance_test==
#chinese
@@ -169,6 +170,12 @@ sub_str_SW.control
tcname_OK.control
tcname_SW.control
+#predefFunction2:
+predefFunctTest.control
+#predefFunctTest.tc_predef_oct2char_good1 //fail, TODO: bugfix, see in single_bugs.cfg
+#predefFunctTest.tc_predef_oct2char_good2 //fail, TODO: bugfix
+#predefFunctTest.tc_predef_oct2char_octetstr_elem //fail, TODO: bugfix
+
### RAW ###
Annex_E_variants.control
Bug521125.control
diff --git a/Regression_Test_java/src/implicitOmit/IOAsn.asn b/Regression_Test_java/src/implicitOmit/IOAsn.asn
new file mode 100644
index 0000000000000000000000000000000000000000..64fee224c7c0334d8dc11623ace003f0ffa14ae5
--- /dev/null
+++ b/Regression_Test_java/src/implicitOmit/IOAsn.asn
@@ -0,0 +1,31 @@
+--/////////////////////////////////////////////////////////////////////////////
+-- Copyright (c) 2000-2019 Ericsson Telecom AB
+-- All rights reserved. This program and the accompanying materials
+-- are made available under the terms of the Eclipse Public License v2.0
+-- which accompanies this distribution, and is available at
+-- https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
+--
+-- Contributors:
+-- Balasko, Jeno
+-- Baranyi, Botond
+--
+--/////////////////////////////////////////////////////////////////////////////
+IOAsn
+DEFINITIONS
+
+AUTOMATIC TAGS ::=
+
+BEGIN
+
+AsnSequence ::= SEQUENCE {
+ field1 ENUMERATED { enumVal } OPTIONAL,
+ field2 CHOICE {
+ alt1 INTEGER,
+ alt2 INTEGER
+ } OPTIONAL,
+ field3 INTEGER OPTIONAL,
+ field4 INTEGER OPTIONAL
+}
+
+
+END
diff --git a/Regression_Test_java/src/implicitOmit/config.cfg b/Regression_Test_java/src/implicitOmit/config.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..fbc942eacde37c95d658b10b3a5a9946dfc06044
--- /dev/null
+++ b/Regression_Test_java/src/implicitOmit/config.cfg
@@ -0,0 +1,36 @@
+###############################################################################
+# Copyright (c) 2000-2019 Ericsson Telecom AB
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v2.0
+# which accompanies this distribution, and is available at
+# https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
+#
+# Contributors:
+# Balasko, Jeno
+# Kovacs, Ferenc
+# Raduly, Csaba
+#
+###############################################################################
+[LOGGING]
+ConsoleMask := ERROR | WARNING | TESTCASE | STATISTICS
+
+LogSourceInfo := Single
+LogEventTypes := Detailed
+
+[MODULE_PARAMETERS]
+marr := { [1] := { c := "clementin" } }
+# Empty initialization is not possible from here.
+# mrec1 := { }
+mrec1 := { c := "clementin" }
+mset1 := { c := "cup" }
+mrec2 := { mr2 := { c := "cello" } }
+mset2 := { ms2 := { c := "cello" } }
+muni := { mr2 := { mr2 := { c := "cuba" } } }
+mrecof1 := { [1] := { c := "clinton" } }
+msetof1 := { [1] := { c := "clinton" } }
+mrecof2 := { [1] := { mr2 := { c := "clinton" } } }
+msetof2 := { [1] := { ms2 := { c := "clinton" } } }
+
+[EXECUTE]
+io.control
+
diff --git a/Regression_Test_java/src/implicitOmit/io.ttcn b/Regression_Test_java/src/implicitOmit/io.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..75a52d3125d5a2567dcfe9447baad414f21553e2
--- /dev/null
+++ b/Regression_Test_java/src/implicitOmit/io.ttcn
@@ -0,0 +1,614 @@
+/******************************************************************************
+ * Copyright (c) 2000-2019 Ericsson Telecom AB
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v2.0
+ * which accompanies this distribution, and is available at
+ * https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
+ *
+ * Contributors:
+ * Balasko, Jeno
+ * Baranyi, Botond
+ * Kovacs, Ferenc
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module io {
+
+import from IOAsn all;
+
+type component O {}
+
+
+//The following TTCN code is not accepted (from HN81328)
+
+type record MyRecord1 {
+ integer a,
+ boolean b optional
+ // , float f
+}
+
+type set MySet1 {
+ integer a,
+ boolean b optional
+ // , float f
+}
+
+type record MyRecord2 {
+ MyRecord1 m
+}
+
+type set MySet2 {
+ MySet1 m
+}
+
+template MyRecord1 MyTemplate1ln := { ? }
+with {optional "implicit omit"} // b is set to omit, ERROR BY TITAN
+
+//The compiler complains that there are too few elements in the list (one instead of two).
+// Common::Location::error is called from from Ttcn::Template::set_templatetype
+// in case TEMPLATE_LIST
+
+//The following (using assignment notation) is accepted:
+
+template MyRecord1 MyTemplate1an := { a := ? }
+with {optional "implicit omit"} // b is set to omit
+
+template MySet1 MySetTemplate1an := { a := ? }
+with {optional "implicit omit"} // b is set to omit
+
+function check1(in template MyRecord1 r1, in boolean a_init1, in boolean b_init1,
+ out charstring reason1) return boolean
+{
+ var charstring t_str := log2str(r1);
+ // looks like: { a := ?, b := <uninitialized template> }
+ if (not a_init1 and not b_init1)
+ {
+ return t_str == "<uninitialized template>";
+ }
+ else
+ {
+ var charstring rx := "{ a := (*), b := (*) }";
+
+ var charstring grp := regexp(t_str, rx, 0);
+ log("grp for a :", grp);
+ if (grp != "?") { // a is always expected to be '?'
+ reason1 := " a should be ";
+ if (a_init1) { reason1 := reason1 & "initialised" }
+ else { reason1 := reason1 & "uninitialised" } // never gets here
+ return false;
+ }
+
+ grp := regexp(t_str, rx, 1);
+ log("grp for b :", grp);
+ reason1 := " b should be "
+
+ if (b_init1) {
+ if (grp != "omit") {
+ reason1 := reason1 & "initialised"
+ return false;
+ }
+ }
+ else {
+ if (grp != "<uninitialized template>") {
+ reason1 := reason1 & "uninitialised"
+ return false;
+ }
+ }
+ return true;
+ }
+}
+
+function check1s(in template MySet1 r5, in boolean a_init5, in boolean b_init5,
+ out charstring reason5) return boolean
+{
+ var charstring t_str := log2str(r5);
+ // looks like: { a := ?, b := <uninitialized template> }
+ if (not a_init5 and not b_init5)
+ {
+ return t_str == "<uninitialized template>";
+ }
+ else
+ {
+ var charstring rx := "{ a := (*), b := (*) }";
+
+ var charstring grp := regexp(t_str, rx, 0);
+ log("grp for a :", grp);
+ if (grp != "?") { // a is always expected to be '?'
+ reason5 := " a should be ";
+ if (a_init5) { reason5 := reason5 & "initialised" }
+ else { reason5 := reason5 & "uninitialised" } // never gets here
+ return false;
+ }
+
+ grp := regexp(t_str, rx, 1);
+ log("grp for b :", grp);
+ reason5 := " b should be "
+
+ if (b_init5) {
+ if (grp != "omit") {
+ reason5 := reason5 & "initialised"
+ return false;
+ }
+ }
+ else {
+ if (grp != "<uninitialized template>") {
+ reason5 := reason5 & "uninitialised"
+ return false;
+ }
+ }
+ return true;
+ }
+}
+
+function check2(in template MyRecord2 r2, in boolean a_init2, in boolean b_init2,
+ out charstring reason2) return boolean
+{
+ if (a_init2 or b_init2) {
+ return check1(r2.m, a_init2, b_init2, reason2);
+ }
+ else {
+ return log2str(r2) == "<uninitialized template>";
+ }
+}
+
+function check2s(in template MySet2 r2s, in boolean a_init2s, in boolean b_init2s,
+ out charstring reason2s) return boolean
+{
+ if (a_init2s or b_init2s) {
+ return check1s(r2s.m, a_init2s, b_init2s, reason2s);
+ }
+ else {
+ return log2str(r2s) == "<uninitialized template>";
+ }
+}
+
+/***************************** from 27.7 of the TTCN3 standard 4.1.1 *****************************/
+
+// reference templates with explicitly set fields
+template MyRecord1 MyTemplate1 := { a := ?, b := omit }
+template MyRecord2 MyTemplate2 := { m := { a := ?, b := omit }}
+
+template MySet1 MySetTemplate1 := { a := ?, b := omit }
+template MySet2 MySetTemplate2 := { m := { a := ?, b := omit }}
+
+
+testcase tc12() runs on O
+{
+ var charstring reason;
+ if (check1(MyTemplate1, true, true, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason); }
+
+ if (check1s(MySetTemplate1, true, true, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason); }
+
+ if (check2(MyTemplate2, true, true, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason); }
+
+ if (check2s(MySetTemplate2, true, true, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason); }
+}
+
+// reference templates
+template MyRecord1 MyTemplate1a := { a := ? } // b is undefined
+template MyRecord1 MyTemplate1b := { a := ? } with {optional "explicit omit"} // b is undefined
+
+template MySet1 MySetTemplate1a := { a := ? } // b is undefined
+template MySet1 MySetTemplate1b := { a := ? } with {optional "explicit omit"} // b is undefined
+
+testcase tc1ab() runs on O
+{
+ var charstring reason;
+ if (check1(MyTemplate1a, true, false, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason); }
+
+ if (check1s(MySetTemplate1a, true, false, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason); }
+
+ if (check1(MyTemplate1b, true, false, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason); }
+
+ if (check1s(MySetTemplate1b, true, false, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason); }
+}
+
+template MyRecord2 MyTemplate2a := {} // m and its subfields are undefined, ERROR BY TITAN
+template MyRecord2 MyTemplate2b := { m := { a := ?}}; // m.b is undefined
+template MySet2 MySetTemplate2b := { m := { a := ?}}; // m.b is undefined
+
+testcase tc2ab() runs on O
+{
+ var charstring reason;
+ if (check2(MyTemplate2a, false, false, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason); }
+
+ if (check2(MyTemplate2b, true, false, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason); }
+
+ if (check2s(MySetTemplate2b, true, false, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason); }
+}
+
+// templates with attribute
+
+template MyRecord1 MyTemplate11 := { a := ? } with {optional "implicit omit"}
+// same as MyTemplate1, b is set to omit
+template MySet1 MySetTemplate11 := { a := ? } with {optional "implicit omit"}
+
+template MyRecord2 MyTemplate21 := { m := { a := ?}} with {optional "implicit omit"}
+// same as MyTemplate2, by recursive application of the attribute
+template MySet2 MySetTemplate21 := { m := { a := ?}} with {optional "implicit omit"}
+
+testcase tc_11() runs on O
+{
+ var charstring reason;
+ if (check1(MyTemplate11, true, true, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason, MyTemplate11); }
+
+ if (check1s(MySetTemplate11, true, true, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason, MyTemplate11); }
+}
+
+testcase tc_21() runs on O
+{
+ var charstring reason;
+ if (check2(MyTemplate21, true, true, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason, MyTemplate21); }
+
+ if (check2s(MySetTemplate21, true, true, reason)) { setverdict(pass); }
+ else { setverdict(fail, reason, MyTemplate21); }
+}
+
+template MyRecord2 MyTemplate22 := { m := MyTemplate1a } with {optional "implicit omit"}
+// same as MyTemplate2, { m := { a := ?, b := omit }}, by recursive application of the attribute
+// MyTemplate1a has b undefined
+template MySet2 MySetTemplate22 := { m := MySetTemplate1a } with {optional "implicit omit"}
+
+testcase tc_22() runs on O
+{
+ var charstring reason;
+ if (check2(MyTemplate22, true, false, reason)) { setverdict(pass); }
+ // According to the standard, this ^^^^^ should be true, but Titan does not implement recursive implicit omit
+ else { setverdict(fail, MyTemplate22, reason); }
+
+ if (check2s(MySetTemplate22, true, false, reason)) { setverdict(pass); }
+ // According to the standard, this ^^^^^ should be true, but Titan does not implement recursive implicit omit
+ else { setverdict(fail, MyTemplate22, reason); }
+}
+
+template MyRecord2 MyTemplate23 := {} with {optional "implicit omit"} // ERROR BY TITAN
+// same as MyTemplate2a, m remains undefined
+
+testcase tc_23() runs on O
+{
+ var charstring reason;
+ if (check2(MyTemplate23, false, false, reason)) { setverdict(pass); }
+ else { setverdict(fail, MyTemplate23, reason); }
+}
+
+template MyRecord2 MyTemplate24 := { m := MyTemplate1b } with {optional "implicit omit"}
+// same as MyTemplate2b, the attribute on the lower scope is not overwritten
+template MySet2 MySetTemplate24 := { m := MySetTemplate1b } with {optional "implicit omit"}
+
+testcase tc_24() runs on O
+{
+ var charstring reason;
+ if (check2(MyTemplate22, true, false, reason)) { setverdict(pass); }
+ else { setverdict(fail, MyTemplate24, reason); }
+
+ if (check2s(MySetTemplate22, true, false, reason)) { setverdict(pass); }
+ else { setverdict(fail, MyTemplate24, reason); }
+}
+
+template MyRecord2 MyTemplate25 := { m := MyTemplate1b } with {optional override "implicit omit"}
+// same as MyTemplate2, the attribute on the lower scope is overwritten
+// MyTemplate1b has b undefined and (redundant) explicit omit
+
+testcase tc_25() runs on O
+{
+ var charstring reason;
+ if (check2(MyTemplate25, true, false, reason)) { setverdict(pass); }
+ // According to the standard, this ^^^^^ should be true, but Titan does not implement recursive implicit omit
+ else { setverdict(fail, MyTemplate25, reason); }
+}
+
+/***************************** from 6.2 ***************************/
+type record R62 {
+ integer f1,
+ integer f2 optional,
+ integer f3,
+ integer f4 optional,
+ integer f5 optional
+}
+
+template R62 x1 := { 1, -, 2 } with {optional "implicit omit"}
+template R62 x2 := { 1, 2 } with {optional "implicit omit"}
+template R62 x3 := { 1, 2, 3 } with {optional "implicit omit"}
+// "const" gives the same old error:
+// Too few elements in value list notation for type `@io.R62'
+
+testcase tc62() runs on O
+{
+ var charstring logged;
+ logged := log2str(x1);
+ if (match(logged, "{ f1 := 1, f2 := omit, f3 := 2, f4 := omit, f5 := omit }")) { setverdict(pass); }
+ else { setverdict(fail, logged); }
+
+ logged := log2str(x2);
+ if (match(logged, "{ f1 := 1, f2 := 2, f3 := <uninitialized template>, f4 := omit, f5 := omit }")) { setverdict(pass); }
+ else { setverdict(fail, logged); }
+
+ logged := log2str(x3);
+ if (match(logged, "{ f1 := 1, f2 := 2, f3 := 3, f4 := omit, f5 := omit }")) { setverdict(pass); }
+ else { setverdict(fail, logged); }
+}
+
+//testcase passer() runs on O { setverdict(pass); }
+
+///////////////////////
+// MODULE PARAMETERS //
+///////////////////////
+type myrec1 myarr[2]
+type record myrec1 { integer i optional, charstring c }
+type set myset1 { integer i optional, charstring c }
+type record myrec2 { integer i optional, myrec1 mr1 optional, myrec1 mr2 }
+type set myset2 { integer i optional, myset1 ms1 optional, myset1 ms2 }
+type union myuni { integer i, myrec1 mr1, myrec2 mr2 }
+type record of myrec1 myrecof1
+type set of myrec1 mysetof1
+type record of myrec2 myrecof2
+type set of myset2 mysetof2
+modulepar myarr marr with { optional "implicit omit" }
+modulepar myrec1 mrec1 with { optional "implicit omit" }
+modulepar myset1 mset1 with { optional "implicit omit" }
+modulepar myrec2 mrec2 with { optional "implicit omit" }
+modulepar myset2 mset2 with { optional "implicit omit" }
+modulepar myuni muni with { optional "implicit omit" }
+modulepar myrecof1 mrecof1 with { optional "implicit omit" }
+modulepar mysetof1 msetof1 with { optional "implicit omit" }
+modulepar myrecof2 mrecof2 with { optional "implicit omit" }
+modulepar mysetof2 msetof2 /*:= { [0] := { ms2 := { c := "clinton" } } }*/ with { optional "implicit omit" }
+
+testcase tc_iompar_recset() runs on O
+{
+ // For empty records:
+ // B: { i := <unbound>, c := <unbound> }
+ // A: { i := omit, c := <unbound> }
+ var myrec1 brec1 := { c := "clementin" }
+ var myrec1 arec1 := { i := omit, c := "clementin" }
+ if (log2str(mrec1) == log2str(arec1)) { setverdict(pass) } else { setverdict(fail) }
+ // Empty sets are not allowed.
+ var myset1 bset1 := { c := "cup" }
+ var myset1 aset1 := { i := omit, c := "cup" }
+ if (log2str(mset1) == log2str(aset1)) { setverdict(pass) } else { setverdict(fail) }
+ // B: { i := <unbound>, mr1 := <unbound>, mr2 := { i := <unbound>, c := "cello" } }
+ // A: { i := omit, mr1 := omit, mr2 := { i := omit, c := "cello" } }
+ var myrec2 brec2 := { mr2 := { c := "cello" } }
+ var myrec2 arec2 := { omit, omit, { i := omit, c := "cello" } }
+ if (log2str(mrec2) == log2str(arec2)) { setverdict(pass) } else { setverdict(fail) }
+ // B: { i := <unbound>, ms1 := <unbound>, ms2 := { i := <unbound>, c := "cello" } }
+ // A: { i := omit, ms1 := omit, ms2 := { i := omit, c := "cello" } }
+ var myset2 bset2 := { ms2 := { c := "cello" } }
+ var myset2 aset2 := { i := omit, ms1 := omit, ms2 := { i := omit, c := "cello" } }
+ if (log2str(mset2) == log2str(aset2)) { setverdict(pass) } else { setverdict(fail) }
+}
+
+testcase tc_iompar_uni() runs on O
+{
+ // B: { mr2 := { i := <unbound>, mr1 := <unbound>, mr2 := { i := <unbound>, c := "cuba" } } }
+ // A: { mr2 := { i := omit, mr1 := omit, mr2 := { i := omit, c := "cuba" } } }
+ var myuni buni := { mr2 := { mr2 := { c := "cuba" } } }
+ var myuni auni := { mr2 := { i := omit, mr1 := omit, mr2 := { i := omit, c := "cuba" } } }
+ if (log2str(muni) == log2str(auni)) { setverdict(pass) } else { setverdict(fail) }
+}
+
+testcase tc_iompar_listarr() runs on O
+{
+ // B: { { i := <unbound>, c := <unbound> }, { i := <unbound>, c := "clementin" } }
+ // A: { { i := <unbound>, c := <unbound> }, { i := omit, c := "clementin" } }
+ var myarr barr := { [1] := { c := "clementin" } }
+ var myarr aarr := { [1] := { i := omit, c := "clementin" } }
+ if (log2str(marr) == log2str(aarr)) { setverdict(pass) } else { setverdict(fail) }
+ // B: { { i := <unbound>, c := <unbound> }, { i := <unbound>, c := "clinton" } }
+ // A: { { i := <unbound>, c := <unbound> }, { i := omit, c := "clinton" } }
+ // Unbound values will not be checked at all.
+ var myrecof1 brecof1 := { [1] := { c := "clinton" } }
+ var myrecof1 arecof1 := { [1] := { i := omit, c := "clinton" } }
+ if (log2str(mrecof1) == log2str(arecof1)) { setverdict(pass) } else { setverdict(fail) }
+ // B: { { i := <unbound>, c := <unbound> }, { i := <unbound>, c := "clinton" } }
+ // A: { { i := <unbound>, c := <unbound> }, { i := omit, c := "clinton" } }
+ var mysetof1 bsetof1 := { [1] := { c := "clinton" } }
+ var mysetof1 asetof1 := { [1] := { i := omit, c := "clinton" } }
+ if (log2str(msetof1) == log2str(asetof1)) { setverdict(pass) } else { setverdict(fail) }
+ // B: { { i := <unbound>, mr1 := <unbound>, mr2 := { i := <unbound>, c := <unbound> } }, { i := <unbound>, mr1 := <unbound>, mr2 := { i := <unbound>, c := "clinton" } } }
+ // A: { { i := <unbound>, mr1 := <unbound>, mr2 := { i := <unbound>, c := <unbound> } }, { i := omit, mr1 := omit, mr2 := { i := omit, c := "clinton" } } }
+ var myrecof2 brecof2 := { [1] := { mr2 := { c := "clinton" } } }
+ var myrecof2 arecof2 := { [1] := { i := omit, mr1 := omit, mr2 := { i := omit, c := "clinton" } } }
+ if (log2str(mrecof2) == log2str(arecof2)) { setverdict(pass) } else { setverdict(fail) }
+ // B: { { i := <unbound>, ms1 := <unbound>, ms2 := { i := <unbound>, c := <unbound> } }, { i := <unbound>, ms1 := <unbound>, ms2 := { i := <unbound>, c := "clinton" } } }
+ // A: { { i := <unbound>, ms1 := <unbound>, ms2 := { i := <unbound>, c := <unbound> } }, { i := omit, ms1 := omit, ms2 := { i := omit, c := "clinton" } } }
+ var mysetof2 bsetof2 := { [1] := { ms2 := { c := "clinton" } } }
+ var mysetof2 asetof2 := { [1] := { i := omit, ms1 := omit, ms2 := { i := omit, c := "clinton" } } }
+ if (log2str(msetof2) == log2str(asetof2)) { setverdict(pass) } else { setverdict(fail) }
+}
+
+type record MyRecord {
+ integer field1 optional,
+ integer field2 optional,
+ MySubRecord subRecord optional
+}
+type record MySubRecord {
+ integer subField1 optional,
+ integer subField2 optional
+}
+
+template MyRecord t_MyRecord1(integer v_int1, integer v_int2, MySubRecord v_subRecord) := {
+ field1 := v_int1,
+ field2 := v_int2,
+ subRecord := v_subRecord
+}
+
+template MyRecord t_MyRecord2(integer v_int1, integer v_int2, MySubRecord v_subRecord) modifies t_MyRecord1 := {
+ subRecord := v_subRecord
+} // without { optional "implicit omit" }
+
+template MyRecord t_MyRecord2_io(integer v_int1, integer v_int2, MySubRecord v_subRecord) modifies t_MyRecord1 := {
+ subRecord := v_subRecord
+} with { optional "implicit omit" }
+
+template MyRecord t_MyRecord2_io2(integer v_int1, integer v_int2, MySubRecord v_subRecord) modifies t_MyRecord1 := {
+ field1 := v_int1,
+ field2 := v_int2,
+ subRecord := v_subRecord
+} with { optional "implicit omit" }
+
+template MySubRecord t_MySubRecord(integer v_int1, integer v_int2) := {
+ subField1 := v_int1,
+ subField2 := v_int2
+} with { optional "implicit omit" }
+
+// HP93133: "Implicit omit overwrites attributes of modified template"
+testcase tc_HP93133() runs on O {
+ var MySubRecord subRecord := valueof(t_MySubRecord(1, 2)) // 1,2
+ var MyRecord record1 := valueof(t_MyRecord1(5, 6, subRecord)) // 5,6,1,2
+ // modifies without implicit omit:
+ var MyRecord record2 := valueof(t_MyRecord2(7, 8, subRecord)) // 7,8,1,2
+ if (record2 == { 7, 8, { 1, 2 } }) { setverdict(pass) } else { setverdict(fail) }
+ // modifies, with implicit omit:
+ var MyRecord record3 := valueof(t_MyRecord2_io(7, 8, subRecord)); // 7,8,1,2
+ if (record3 == { 7, 8, { 1, 2 } }) { setverdict(pass) } else { setverdict(fail) } // parent is not modified anymore...
+ var MyRecord record4 := valueof(t_MyRecord2_io2(0, 0, subRecord)); // 0,0,1,2
+ if (record4 == { 0, 0, { 1, 2 } }) { setverdict(pass) } else { setverdict(fail) } // ...unless it's requested
+}
+
+// HQ30261: "Implicit omit doesn't work for modulepar default values"
+type record MyOwnRecord { integer f1, integer f2 optional }
+
+modulepar MyOwnRecord tsp_MyOwnRecord_init := { f1 := 1 } with { optional "implicit omit" }
+modulepar MyOwnRecord tsp_MyOwnRecord_empty with { optional "implicit omit" }
+
+testcase tc_HQ30261() runs on O {
+ if (match(tsp_MyOwnRecord_init, { 1, omit })) { setverdict(pass) } else { setverdict(fail) }
+ if (not isbound(tsp_MyOwnRecord_empty.f1) and tsp_MyOwnRecord_empty.f2 == omit) { setverdict(pass) } else { setverdict(fail) }
+}
+
+// Implicit omit for fields of records embedded in a union
+type union Something {
+ Outer outer,
+ Inner inner,
+ octetstring os
+}
+
+type record Outer {
+ integer i,
+ Inner inner optional
+}
+
+type record Inner {
+ float f,
+ charstring cs optional
+}
+
+const Something c_something_value := {
+ outer := {
+ i := 10,
+ inner := {
+ f := 7.1
+ }
+ }
+} with { optional "implicit omit" }
+
+template Something t_something_target := {
+ outer := {
+ i := 10,
+ inner := {
+ f := 7.1,
+ cs := omit
+ }
+ }
+}
+
+testcase tc_io_embedded() runs on O
+{
+ if (match(c_something_value, t_something_target)) { setverdict(pass); }
+ else { setverdict(fail, c_something_value); }
+}
+
+// Implicit omit specified with the not used symbol (-) with the value list notation
+type record of Outer RoO;
+
+const RoO c_notused_value := {
+ { 3, - },
+ { 4, { 3.9, - } }
+} with { optional "implicit omit" }
+
+template RoO t_notused_target := {
+ { 3, omit },
+ { 4, { 3.9, omit } }
+} with { optional "implicit omit" }
+
+testcase tc_io_notused() runs on O
+{
+ if (match(c_notused_value, t_notused_target)) { setverdict(pass); }
+ else { setverdict(fail, c_notused_value); }
+}
+
+// Implicit omit on an ASN.1 record, with only empty brackets (which is considered as value list notation)
+template AsnSequence t_asn_rec_empty := { } with { optional "implicit omit" };
+template AsnSequence t_asn_rec_empty_exp := { omit, omit, omit, omit };
+
+testcase tc_io_asn_record_empty() runs on O
+{
+ if (log2str(t_asn_rec_empty) == log2str(t_asn_rec_empty_exp)) { setverdict(pass); }
+ else { setverdict(fail, t_asn_rec_empty); }
+}
+
+control {
+execute(tc12());
+execute(tc1ab());
+execute(tc2ab());
+
+execute(tc_11());
+execute(tc_21());
+
+execute(tc_22());
+execute(tc_23());
+execute(tc_24());
+execute(tc_25());
+
+execute(tc62());
+
+log("MyTemplate1ln = ",MyTemplate1ln);
+log("MyTemplate1an = ",MyTemplate1an);
+log("MyTemplate1 = ",MyTemplate1);
+log("MyTemplate2 = ",MyTemplate2);
+log("MyTemplate1a = ",MyTemplate1a);
+log("MyTemplate1b = ",MyTemplate1b);
+log("MyTemplate2a = ",MyTemplate2a);
+log("MyTemplate2b = ",MyTemplate2b);
+log("MyTemplate11 = ",MyTemplate11);
+log("MyTemplate21 = ",MyTemplate21);
+log("MyTemplate22 = ",MyTemplate22);
+log("MyTemplate23 = ",MyTemplate23);
+log("MyTemplate24 = ",MyTemplate24);
+log("MyTemplate25 = ",MyTemplate25);
+
+log("x1=", x1);
+log("x2=", x2);
+log("x3=", x3);
+
+execute(tc_iompar_recset())
+execute(tc_iompar_uni())
+execute(tc_iompar_listarr())
+execute(tc_HP93133())
+execute(tc_HQ30261())
+
+execute(tc_io_embedded());
+execute(tc_io_notused());
+execute(tc_io_asn_record_empty());
+}
+with {
+ optional "implicit omit"
+}
+
+}
+
diff --git a/Regression_Test_java/src/predefFunction2/config.cfg b/Regression_Test_java/src/predefFunction2/config.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..d6750873f5d148f2b1995aff1ce6b1975191493b
--- /dev/null
+++ b/Regression_Test_java/src/predefFunction2/config.cfg
@@ -0,0 +1,19 @@
+###############################################################################
+# Copyright (c) 2000-2019 Ericsson Telecom AB
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v2.0
+# which accompanies this distribution, and is available at
+# https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
+#
+# Contributors:
+# Balasko, Jeno
+# 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_java/src/predefFunction2/predefFunctTest.ttcn b/Regression_Test_java/src/predefFunction2/predefFunctTest.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..55317438f245c0143198147b158ba4ee29599230
--- /dev/null
+++ b/Regression_Test_java/src/predefFunction2/predefFunctTest.ttcn
@@ -0,0 +1,5237 @@
+/******************************************************************************
+* Copyright (c) 2000-2019 Ericsson Telecom AB
+* All rights reserved. This program and the accompanying materials
+* are made available under the terms of the Eclipse Public License v2.0
+* which accompanies this distribution, and is available at
+* https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html
+*
+* Contributors:
+* Balasko, Jeno
+*
+******************************************************************************/
+//These tests are supplementary testcases to ../predefFunction/*
+//If commented testcases are commented back, the code can be used in static test, as well
+module predefFunctTest {
+
+const charstring c_cs_empty := ""
+type record of bitstring RoBS;
+type record of hexstring RoHS;
+type record of octetstring RoOS;
+type record of integer RoI;
+type record of charstring RoCS;
+type record of universal charstring RoUCS;
+
+type set of integer SoI;
+const bitstring c_bs_empty1 := ''B
+const integer c_2e31 := 2147483648;
+const integer c_2e32 := 4294967296;
+const RoI c_roi_empty := {};
+const RoI c_roi_1 := {-1}
+const RoI c_roi_2 := {-2, -1}
+const RoI c_roi3 := {-3,-2,-1}
+
+type component CT{}
+
+//====== str2float ==========
+testcase tc_predef_str2float_empty() runs on CT {
+ var charstring vl_cs_empty := "";
+ @try {
+ var float f := str2float( vl_cs_empty & c_cs_empty);
+ setverdict(fail, "exception was expected")
+
+ } @catch(e) {
+ setverdict(pass, "exception catched")
+ }
+}
+
+testcase tc_predef_str2float_empty2() runs on CT {
+ var charstring vl_cs_empty := "";
+ @try {
+ var float f := str2float( vl_cs_empty);
+ setverdict(fail, "exception was expected")
+
+ } @catch(e) {
+ setverdict(pass, "exception catched")
+ }
+}
+
+type record of float RoF;
+
+// good cases
+testcase tc_predef_str2float_good1() runs on CT {
+ var RoCS vl_roc := {"1","-123", "-0.000","0.0","+0.0", "1.0", "002.34567890", "+003.000000", "+4.0","5.0e+0", "-6.0e+2", "7.125e+10", "8.250e+100","9e5" }
+ var RoF vl_expected := {1.0, -123.0, -0.0, 0.0, +0.0,1.0, 2.34567890, 3.0, 4.0, 5.0,-600.0, 71.25e+9, 8.25e100, 9e5 }
+ var integer N := sizeof( vl_roc );
+
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(str2float(vl_roc[i])==vl_expected[i]) {
+ // setverdict(pass);
+ log(i);
+ } else {
+ setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",str2float(vl_roc[i]));
+ }
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_str2float_good2() runs on CT {
+ var charstring vl_cs := "infinity";
+ if(str2float(vl_cs) == infinity){
+ setverdict(pass)
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_str2float_good2a() runs on CT {
+ var charstring vl_cs := "infinity";
+ if (infinity == str2float(vl_cs)) {
+ setverdict(pass)
+ } else {
+ setverdict(fail);
+ }
+}
+
+//compile time evaluation
+testcase tc_predef_str2float_good2b() runs on CT {
+ if(str2float("infinity") == infinity){
+ setverdict(pass)
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_str2float_good2c() runs on CT {
+ if(infinity == str2float("infinity")){
+ setverdict(pass)
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_str2float_good2d() runs on CT {
+ var charstring vl_cs := "INF";
+ @try {
+ if(str2float(vl_cs) == infinity){
+ setverdict(fail, "DTE expected")
+ } else {
+ setverdict(fail,"DTE expected");
+ }
+ } @catch(e) {
+ setverdict(pass,"DTE catched")
+ }
+}
+
+
+
+//compile time evaluation - semantic error
+//testcase tc_predef_str2float_good2d() runs on CT {
+// if(str2float("INF") == infinity){
+// setverdict(pass)
+// } else {
+// setverdict(fail);
+// }
+//}
+testcase tc_predef_str2float_good3() runs on CT {
+ var charstring vl_cs := "-infinity";
+ if(str2float(vl_cs) == -infinity){
+ setverdict(pass)
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_str2float_good3b() runs on CT {
+ if(str2float("-infinity") == -infinity){
+ setverdict(pass)
+ } else {
+ setverdict(fail);
+ }
+}
+
+//Status:fails on cpp, pass on java
+testcase tc_predef_str2float_good4() runs on CT {
+ var charstring vl_cs := "not_a_number";
+ if(str2float(vl_cs) == not_a_number){
+ setverdict(pass)
+ } else {
+ setverdict(fail,"expected not_a_number got:", str2float(vl_cs));
+ }
+}
+//Status:pass on cpp, pass on java
+testcase tc_predef_str2float_good4b() runs on CT {
+ if(str2float("not_a_number") == not_a_number){
+ setverdict(pass)
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_str2float_good4c() runs on CT {
+ var charstring vl_cs := "NaN";
+ @try {
+ if(str2float(vl_cs) == not_a_number){
+ setverdict(fail)
+ } else {
+ setverdict(fail);
+ }
+ } @catch(e) {
+ setverdict(pass,"DTE catched")
+ }
+}
+
+testcase tc_predef_str2float_good5() runs on CT {
+ var charstring vl_cs := "not_a_number";
+ if( not_a_number == str2float(vl_cs) ){
+ setverdict(pass)
+ } else {
+ setverdict(fail,"expected not_a_number got:", str2float(vl_cs));
+ }
+}
+//semantic error
+//testcase tc_predef_str2float_good4d() runs on CT {
+// if(str2float("NaN") == not_a_number){
+// setverdict(pass)
+// } else {
+// setverdict(fail);
+// }
+//}
+
+testcase tc_predef_str2float_bad1() runs on CT {
+ var charstring vl_cs := ".3";
+ @try {
+ var float f := str2float( vl_cs );
+ setverdict(fail, "exception was expected but got:",f)
+
+ } @catch(e) {
+ setverdict(pass, "exception catched")
+ }
+}
+
+//testcase tc_predef_str2float_bad1b() runs on CT {
+// @try {
+// var float f := str2float(".3");//semantic error
+// setverdict(fail, "exception was expected but got:" , f )
+//
+// } @catch(e) {
+// setverdict(pass, "exception catched")
+// }
+//}
+testcase tc_predef_str2float_bad2() runs on CT {
+ var charstring vl_cs := "1.2f3";
+ @try {
+ var float f := str2float( vl_cs & c_cs_empty);
+ setverdict(fail, "exception was expected")
+
+ } @catch(e) {
+ setverdict(pass, "exception catched")
+ }
+}
+
+//testcase tc_predef_str2float_bad2b() runs on CT {
+// @try {
+// var float f := str2float( "1.2f3"); //semantic error
+// setverdict(fail, "exception was expected")
+//
+// } @catch(e) {
+// setverdict(pass, "exception catched")
+// }
+//}
+
+testcase tc_predef_str2float_bad3() runs on CT {
+ var charstring vl_cs := "DADDY1.23";
+ @try {
+ var float f := str2float( vl_cs & c_cs_empty);
+ setverdict(fail, "exception was expected")
+
+ } @catch(e) {
+ setverdict(pass, "exception catched")
+ }
+}
+
+testcase tc_predef_str2float_bad4() runs on CT {
+ var charstring vl_cs := "1.23e23d";
+ @try {
+ var float f := str2float( vl_cs & c_cs_empty);
+ setverdict(fail, "exception was expected")
+
+ } @catch(e) {
+ setverdict(pass, "exception catched")
+ }
+}
+
+//=========== rnd ======================
+testcase tc_predef_rnd() runs on CT {
+ var float vl_f := rnd();
+ var float vl_seed :=3.45e+2;
+ for(var integer i:=0; i<10;i:=i+1){
+ vl_f := rnd();
+ if( 0.0 <= vl_f and vl_f< 1.0) {
+ log(vl_f)
+ } else {
+ setverdict(fail, vl_f);
+ }
+ vl_f := rnd(vl_seed);
+ if( 0.0 <= vl_f and vl_f< 1.0) {
+ log(vl_f)
+ } else {
+ setverdict(fail, vl_f);
+ }
+ setverdict(pass);
+ }
+}
+//====== bit2hex ===============
+
+testcase tc_predef_bit2hex1() runs on CT {
+ var RoBS bs_list := {
+ '0000'B, '0001'B, '0010'B, '0011'B,
+ '0100'B, '0101'B, '0110'B, '0111'B,
+ '1000'B, '1001'B, '1010'B, '1011'B,
+ '1100'B, '1101'B, '1110'B, '1111'B
+ }
+
+ var RoHS hs_list := {
+ '0'H, '1'H, '2'H, '3'H,
+ '4'H, '5'H, '6'H, '7'H,
+ '8'H, '9'H, 'A'H, 'B'H,
+ 'C'H, 'D'H, 'E'H, 'F'H
+ }
+
+ var integer N := lengthof(bs_list);
+ for (var integer i:=0; i<N; i:=i+1){
+ if(bit2hex(bs_list[i])==hs_list[i]) {
+ setverdict(pass,bs_list[i],"->",bit2hex(bs_list[i])," exp:", hs_list[i]);
+ } else {
+ setverdict(fail,bs_list[i],"->",bit2hex(bs_list[i])," exp:", hs_list[i]);
+ }
+ }
+}
+
+//longer:
+testcase tc_predef_bit2hex2() runs on CT {
+ var bitstring vl_bs1 := '0001'B, vl_bs2 :='0010'B,vl_bsF := '1111'B,vl_bsA:= '1010'B;
+
+ var hexstring vl_hs := bit2hex( vl_bs1 & vl_bs2 & vl_bsF & vl_bsA);
+ if (vl_hs == '12FA'H) {
+ setverdict(pass)
+ } else {
+ setverdict(fail, "expected '12FA'H got:", vl_hs);
+ }
+}
+//bitstring element is the argument
+testcase tc_predef_bit2hex_bitstr_element() runs on CT {
+ var bitstring vl_bs := '001'B;
+ var RoHS exp := {'0'H,'0'H,'1'H};
+ for( var integer i:=0; i< lengthof(vl_bs); i:=i+1) {
+ if( bit2hex(vl_bs[i]) == exp[i]){
+ setverdict(pass,vl_bs[i],"->",bit2hex(vl_bs[i])," exp:", exp[i])
+ } else {
+ setverdict(fail)
+ }
+ }
+}
+
+//==== bit2oct ====
+testcase tc_predef_bit2oct1() runs on CT {
+ var RoBS bs_list := {
+ '0000'B, '0001'B, '0010'B, '0011'B,
+ '0100'B, '0101'B, '0110'B, '0111'B,
+ '1000'B, '1001'B, '1010'B, '1011'B,
+ '1100'B, '1101'B, '1110'B, '1111'B
+ }
+
+ var RoOS os_list := {
+ '00'O, '01'O, '02'O, '03'O,
+ '04'O, '05'O, '06'O, '07'O,
+ '08'O, '09'O, '0A'O, '0B'O,
+ '0C'O, '0D'O, '0E'O, '0F'O
+ }
+
+ var integer N := lengthof(bs_list);
+ for (var integer i:=0; i<N; i:=i+1){
+ if(bit2oct(bs_list[i])==os_list[i]) {
+ setverdict(pass,bs_list[i],"->",bit2oct(bs_list[i])," exp:", os_list[i]);
+ } else {
+ setverdict(fail,bs_list[i],"->",bit2oct(bs_list[i])," exp:", os_list[i]);
+ }
+ }
+}
+
+testcase tc_predef_bit2oct2() runs on CT {
+ var bitstring vl_bs1 := '0001'B, vl_bs2 :='0010'B,vl_bsF := '1111'B,vl_bsA:= '1010'B;
+
+ var octetstring vl_os := bit2oct( vl_bs1 & vl_bs2 & vl_bsF & vl_bsA);
+ if (vl_os == '12FA'O) {
+ setverdict(pass)
+ } else {
+ setverdict(fail, "expected '12FA'O got:", vl_os);
+ }
+}
+
+//bitstring element is the argument
+testcase tc_predef_bit2oct_bitstr_element() runs on CT {
+ var bitstring vl_bs := '001'B;
+ var RoOS exp := {'00'O,'00'O,'01'O};
+ for( var integer i:=0; i< lengthof(vl_bs); i:=i+1) {
+ if( bit2oct(vl_bs[i]) == exp[i]){
+ setverdict(pass,vl_bs[i],"->",bit2oct(vl_bs[i])," exp:", exp[i])
+ } else {
+ setverdict(fail)
+ }
+ }
+}
+//====== bit2int ===============
+testcase tc_predef_bit2int_good() runs on CT {
+ var RoBS vl_bslist := {'0'B, '00000'B, '1'B, '0001'B,'000000000001'B,'0010'B, '0011'B,'0100'B,'0101'B,
+ '0110'B,'0111'B,'1000'B,'00001000'B,'1001'B,'1010'B, '10000'B, '10001'B
+ }
+ var RoI vl_expectedList := {0,0,1,1,1,2,3,4,5,6,7,8,8,9,10,16,17}
+ var integer N := sizeof(vl_bslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(bit2int(vl_bslist[i])!=vl_expectedList[i]){
+ setverdict(fail, "expected:", vl_expectedList[i]," got:", bit2int(vl_bslist[i]));
+ }
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_bit2int_good_with_space() runs on CT {
+ var bitstring vl_bs := '1 0000'B
+ if (bit2int(vl_bs)!=16 ){
+ setverdict(fail, "expected: 16 got:", bit2int('1 0000'B) );
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_bit2int_good_long1() runs on CT {
+ var bitstring vl_bs := '1 0000 0000 0000 0000'B
+ if (bit2int('1 0000 0000 0000 0000'B)!=65536 ){
+ setverdict(fail, "expected: 65536 got:", bit2int('1 0000 0000 0000 0000'B) );
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_bit2int_good_long2() runs on CT {
+ var bitstring vl_bs := '1 0000 0000 0000 0000'B
+ if (bit2int(vl_bs)!=65536 ){
+ setverdict(fail, "expected: 65536 got:", bit2int(vl_bs) );
+ }
+ setverdict(pass);
+}
+testcase tc_predef_bit2int_good_long3() runs on CT {
+ var bitstring vl_bs := '1 0000 1000 0010 0001'B
+ if (bit2int(vl_bs)!=67617 ){
+ setverdict(fail, "expected: 67617 got:", bit2int(vl_bs) );
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_bit2int_good_long4() runs on CT {
+ var bitstring vl_bs := '10 0000 1000 0010 0001'B
+ if (bit2int(vl_bs)!=133153 ){
+ setverdict(fail, "expected: 133153 got:", bit2int(vl_bs) );
+ }
+ setverdict(pass,"expected: 133153 got:", bit2int(vl_bs));
+}
+
+//longer than 32 bits:
+testcase tc_predef_bit2int_good_long5() runs on CT {
+ var bitstring vl_bs := '0001 0000 0000 0000 0000 0000 0000 0000 0001'B;
+ var integer expected := 4294967297;
+ if (bit2int(vl_bs)!=expected ){
+ setverdict(fail, "expected:", expected, " got:", bit2int(vl_bs) );
+ } else {
+ setverdict(pass,"expected:", expected," got:", bit2int(vl_bs));
+ }
+}
+
+//bitstring element is the argument
+testcase tc_predef_bit2int_bitstr_element() runs on CT {
+ var bitstring vl_bs := '001'B;
+ var RoI exp := {0,0,1};
+ for( var integer i:=0; i< lengthof(vl_bs); i:=i+1) {
+ if( bit2int(vl_bs[i]) == exp[i]){
+ setverdict(pass,vl_bs[i],"->",bit2int(vl_bs[i])," exp:", exp[i])
+ } else {
+ setverdict(fail)
+ }
+ }
+}
+
+//Eclipse Titan handles only space as whitespace
+//testcase tc_predef_bit2int_good_with_whitespace() runs on CT {
+// if (bit2int('1 100000'B)!=16 ){
+// setverdict(fail, "expected: 16 got:", bit2int('1 0000'B) );
+// }
+// setverdict(pass);
+//}
+
+testcase tc_predef_bit2int_good_empty() runs on CT {
+ var bitstring vl_bs :=''B
+ if (bit2int(vl_bs)!=0 ){ //??????
+ setverdict(fail, "expected: 0 got:", bit2int(''B) );
+ }
+ setverdict(pass);
+}
+
+//===== bit2oct =====
+//C.1.15 Bitstring to octetstring
+//bit2oct('111010111'B)= '01D7'O
+testcase tc_predef_bit2oct_good() runs on CT {
+ var RoBS vl_bslist := {'0'B, '00000'B, '1'B, '0001'B,'0000 0000 0001'B,'0010'B, '0011'B,'0100'B,'0101'B,
+ '0110'B,'0111'B,'1000'B,'00001000'B,'1001'B,'1010'B, '10000'B, '10001'B
+ }
+ var RoOS vl_expectedList := {'00'O,'00'O,'01'O,'01'O,'0001'O,'02'O,'03'O,'04'O,'05'O,
+ '06'O,'07'O,'08'O,'08'O,'09'O,'0A'O,'10'O,'11'O}
+ var integer N := sizeof(vl_bslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(bit2oct(vl_bslist[i])!=vl_expectedList[i]){
+ setverdict(fail, "expected (i=",i,") ", vl_expectedList[i]," got:", bit2oct(vl_bslist[i]));
+ }
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_bit2oct_good_with_space() runs on CT {
+ var bitstring vl_bs := '10000'B;
+ if (bit2oct(vl_bs)!='10'O ){
+ setverdict(fail, "expected: '10'O got:", bit2oct('10000'B) );
+ }
+ setverdict(pass);
+}
+
+//===== bit2str =====
+testcase tc_predef_bit2str_good() runs on CT {
+ var RoBS vl_bslist := {'0'B, '00000'B, '1'B, '0001'B,'000000000001'B,'0010'B, '0011'B,'0100'B,'0101'B,
+ '0110'B,'0111'B,'1000'B,'00001000'B,'1001'B,'1010'B, '10000'B, '10001'B
+ }
+ var RoCS vl_expectedList := {"0", "00000", "1", "0001","000000000001","0010", "0011","0100","0101",
+ "0110","0111","1000","00001000","1001","1010", "10000", "10001"
+ }
+ var integer N := sizeof(vl_bslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(bit2str(vl_bslist[i])!=vl_expectedList[i]){
+ setverdict(fail, "expected (i=",i,") ", vl_expectedList[i]," got:", bit2str(vl_bslist[i]));
+ }
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_bit2str_good_with_space() runs on CT {
+ var bitstring vl_bs := '1 0000'B
+ if (bit2str(vl_bs)!="10000" ){
+ setverdict(fail, "expected: \"1 0000\" got:", bit2str('1 0000'B) );
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_bit2str_good_empty() runs on CT {
+ var bitstring vl_bs := ''B
+ if (bit2str(vl_bs)!="" ){
+ setverdict(fail, "expected: \"\" got:", bit2str(''B) );
+ }
+ setverdict(pass);
+}
+
+//bitstring element is the argument
+testcase tc_predef_bit2str_bitstr_element() runs on CT {
+ var bitstring vl_bs := '001'B;
+ var RoCS exp := {"0","0","1"};
+ for( var integer i:=0; i< lengthof(vl_bs); i:=i+1) {
+ if( bit2str(vl_bs[i]) == exp[i]){
+ setverdict(pass,vl_bs[i],"->",bit2str(vl_bs[i])," exp:", exp[i])
+ } else {
+ setverdict(fail)
+ }
+ }
+}
+
+//char2int
+testcase tc_predef_char2int_good() runs on CT {
+ var RoCS vl_cslist := { "a","b", "z", "A","Z", "0","1", "9"," ","!", "\"","~","\n","\b","\t", "\f","\r" }
+ var RoI vl_expectedList := { 97, 98, 122, 65, 90, 48,49,57, 32, 33, 34,126,10,8,9,12,13}
+ var integer N := sizeof(vl_cslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(char2int(vl_cslist[i])!=vl_expectedList[i]){
+ setverdict(fail, "expected (i=",i,") ", vl_expectedList[i]," got:", char2int(vl_cslist[i]));
+ }
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_char2int_good_charstring_element() runs on CT {
+ var charstring cs := "Apple ABBA78-~";
+ var RoI exp := {65,112,112,108,101, 32, 65,66,66,65, 55,56,45,126}
+ for( var integer i:=0; i< lengthof(cs); i:=i+1) {
+ if (char2int(cs[i])==exp[i]) {
+ setverdict(pass, cs[i],"->",char2int(cs[i])," expected: ",exp[i]);
+ } else{
+ setverdict(fail, cs[i],"->",char2int(cs[i])," expected: ",exp[i]);
+ }
+ }
+}
+testcase tc_predef_char2int_bad1() runs on CT {
+ var charstring vl_cs := "aa";
+ @try {
+ var integer vl_i :=char2int(vl_cs);
+ setverdict(fail, "Not expected to reach this line, DTE expected")
+ } @catch(e){
+ setverdict(pass, "DTE catched")
+ }
+}
+
+testcase tc_predef_char2int_bad2() runs on CT {
+ var charstring vl_cs := ""
+ @try {
+ var integer vl_i :=char2int(vl_cs);
+ setverdict(fail, "Not expected to reach this line, DTE expected")
+ } @catch(e){
+ setverdict(pass, "DTE catched")
+ }
+}
+
+testcase tc_predef_char2int_bad3() runs on CT {
+ var charstring vl_cs := "á";//UTF-8
+ @try {
+ var integer vl_i :=char2int(vl_cs);
+ setverdict(fail, "Not expected to reach this line, DTE expected")
+ } @catch(e){
+ setverdict(pass, "DTE catched")
+ }
+}
+
+testcase tc_predef_char2int_bad4() runs on CT {
+ var charstring vl_cs := "á";//UTF-8
+ @try {
+ var integer vl_i :=char2int(vl_cs[0]);
+ setverdict(fail, "Not expected to reach this line, DTE expected")
+ } @catch(e){
+ setverdict(pass, "DTE catched")
+ }
+}
+
+//====== char2oct =====
+//C.1.11 Character to octetstring
+//char2oct ("Tinky-Winky") = '54696E6B792D57696E6B79'O
+testcase tc_predef_char2oct_good1() runs on CT {
+ var RoCS vl_cslist := {"a","b", "z", "A","Z", "0","1", "9"," ","!", "\"", "\\","~" }
+ var RoOS vl_expectedList := { '61'O,'62'O,'7A'O, '41'O, '5A'O,'30'O,'31'O,'39'O,'20'O,'21'O, '22'O, '5C'O,'7E'O }
+ var integer N := sizeof(vl_cslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(char2oct(vl_cslist[i])!=vl_expectedList[i]){
+ setverdict(fail, "expected (i=",i,") ", vl_expectedList[i]," got:", char2oct(vl_cslist[i]));
+ }
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_char2oct_charstring_element() runs on CT {
+ var charstring vl_cslist := "abzAZ019 !\"\\~\b\t\n\f\r\'\"*?"
+ var octetstring vl_expectedList := '61627A415A3031392021225C7E08090A0C0D27222A3F'O
+ var integer N := lengthof(vl_cslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(char2oct(vl_cslist[i])!=vl_expectedList[i]){
+ setverdict(fail, "expected (i=",i,") ", vl_expectedList[i]," got:", char2oct(vl_cslist[i]));
+ }
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_char2oct_good_empty() runs on CT {
+ var charstring vl_cs := "";
+ if (char2oct(vl_cs)!=''O ){
+ setverdict(fail, "expected: \'\'O got:", char2oct("") );
+ }
+ setverdict(pass);
+}
+//char2hexdigit ??
+
+//====== float2int ======
+testcase tc_predef_float2int_good1() runs on CT {
+ // var RoC vl_roc := {"1","-123", "-0.000","0.0","+0.0", "1.0", "002.34567890", "+003.000000", "+4.0","5.0e+0", "-6.0e+2", "7.125e+10", "8.250e+100","9e5" }
+ var RoF vl_rof := {1.0, -123.0, -0.0, 0.0, +0.0,1.0, 2.34567890, 3.0, 4.0, 5.0,-600.0, 71.25e+9, 429496729.6e+1, 9e5, -0.1}
+ var RoI vl_expected := {1,-123,0,0,0,1,2,3,4,5,-600, 71250000000, 4294967296,900000, 0}
+ var integer N := sizeof( vl_rof );
+
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(float2int(vl_rof[i])!=vl_expected[i]) {
+ setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",float2int(vl_rof[i]));
+ }
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_float2int_bad1() runs on CT {
+ var float f := infinity;
+ @try{
+ var integer i := float2int(f);
+ setverdict(fail,"This line should not be reached");
+ } @catch(e){
+ setverdict(pass, "Expected DTE: ",e);
+ }
+}
+//======= float2str ==============
+testcase tc_predef_float2str_good0() runs on CT {
+ // var RoC vl_roc := {"1","-123", "-0.000","0.0","+0.0", "1.0", "002.34567890", "+003.000000", "+4.0","5.0e+0", "-6.0e+2", "7.125e+10", "8.250e+100","9e5" }
+ var RoF vl_rof := {1.0, -123.0, -0.0, 0.0, +0.0,1.0, 2.34567890, 3.0, 4.0, 5.0,-600.0, 71.25e+9, 429496729.6e+1, 9e5, -0.1}
+ var RoCS vl_expected := {"1.000000","-123.000000","-0.000000"}
+ var integer N := 2; //sizeof( vl_rof );
+
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(float2str(vl_rof[i])!=vl_expected[i]) {
+ setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",float2str(vl_rof[i]), ", log2str:", vl_rof[i]);
+ }
+ }
+ setverdict(pass);
+}
+
+//First case
+// -MAX_DECIMAL_FLOAT<f && f<=-MIN_DECIMAL_FLOAT
+//|| (MIN_DECIMAL_FLOAT<=f && MAX_DECIMAL_FLOAT)
+
+// ( Not scientific notation: )
+testcase tc_predef_float2str_good1() runs on CT{
+ var float f := -0.99e+10;
+ var charstring expected := "-9900000000.000000"; // -9 900 000 000
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))} else {setverdict(fail,"Expected:",expected," got: ", log2str(f))}
+}
+
+testcase tc_predef_float2str_good2() runs on CT{
+ var float f := 0.99e+10 ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
+ var charstring expected := "9900000000.000000"; // -9 900 000 000
+ log(f);
+ if(float2str(f)==expected) {
+ setverdict(pass,"Expected:",expected," got: ", float2str(f), " log2str:", f)
+ } else {
+ setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
+}
+
+testcase tc_predef_float2str_good3() runs on CT{
+ var float f := -0.0001 ;
+ var charstring expected := "-0.000100";
+ log(f);
+ var charstring logged := float2str(f);
+ if(logged==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))} else {setverdict(fail,"Expected:",expected," got: ", logged)}
+}
+
+testcase tc_predef_float2str_good4() runs on CT{
+ var float f := 0.0001 ;
+ var charstring expected := "0.000100";
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
+ else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
+}
+
+
+testcase tc_predef_float2str_good5() runs on CT{
+ var float f := -1000.0 ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
+ var charstring expected := "-1000.000000";
+ // var charstring result := float2str(f);
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
+ else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
+}
+testcase tc_predef_float2str_good6() runs on CT{
+ var float f := 1000.0 ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
+ var charstring expected := "1000.000000";
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
+ else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
+}
+
+testcase tc_predef_float2str_good7() runs on CT{
+ var float f := 0.0 ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
+ var charstring expected := "0.000000";
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
+ else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
+}
+
+//2nd case:
+testcase tc_predef_float2str_good8() runs on CT{
+ var float f := infinity ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
+ var charstring expected := "infinity";
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
+ else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
+}
+
+//3rd case:
+testcase tc_predef_float2str_good9() runs on CT{
+ var float f := -infinity ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
+ var charstring expected := "-infinity";
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
+ else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
+}
+
+//4th case not a number
+testcase tc_predef_float2str_good10() runs on CT{
+ var float f := not_a_number ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
+ var charstring expected := "not_a_number";
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
+ else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
+}
+
+
+//5th case: Scientific notation
+//too small or too big absolut value
+testcase tc_predef_float2str_good11() runs on CT{
+ var float f := -1.0e-5 ; //-MIN_DEC_FLOAT<-f && f<MIN_DEC_FLOAT
+ var charstring expected := "-1.000000e-05";
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
+ else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
+}
+
+testcase tc_predef_float2str_good12() runs on CT{
+ var float f := 1.0e-5 ; //f<MIN_DEC_FLOAT
+ var charstring expected := "1.000000e-05";
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
+ else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
+}
+
+testcase tc_predef_float2str_good13() runs on CT{
+ var float f := 0.000099 ;
+ var charstring expected := "9.900000e-05";
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
+ else {setverdict(fail,"Expected:",expected," got: ", float2str(f), " log2str:", f)}
+}
+
+testcase tc_predef_float2str_good14() runs on CT{
+ var float f := -0.000099;
+ var charstring expected := "-9.900000e-05";
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
+ else {setverdict(fail,"Expected:",expected," got: ", float2str(f), "log2str:", f)}
+}
+
+//Status: fails on cpp
+testcase tc_predef_float2str_good15() runs on CT{
+ var float f := 9.987654e+5;
+ var charstring expected := "998765.400000";
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
+ else {setverdict(fail,"Expected:",expected," got: ", float2str(f), "log2str:", f)}
+}
+testcase tc_predef_float2str_good16() runs on CT{
+ var float f := 9.987654e-5;
+ var charstring expected := "9.987654e-05";
+ log(f);
+ if(float2str(f)==expected) {setverdict(pass,"Expected:",expected," got: ", float2str(f))}
+ else {setverdict(fail,"Expected:",expected," got: ", float2str(f), "log2str:", f)}
+}
+//hex2bit
+testcase tc_predef_hex2bit_empty1() runs on CT {
+ if(hex2bit(''H)==''B){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+testcase tc_predef_hex2bit_empty2() runs on CT {
+ var hexstring vl_hs :=''H
+ if(hex2bit(vl_hs)==''B){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+testcase tc_predef_hex2bit_unbound() runs on CT {
+ var hexstring vl_hs;
+ @try {
+ if(hex2bit(vl_hs)==''B){
+ setverdict(fail,"DTE expected");
+ } else {
+ setverdict(fail,"DTE expected");
+ }
+ }@catch(e){
+ setverdict(pass, "Expected DTE catched")
+ }
+}
+
+//testcase tc_predef_hex2bit_good1() runs on CT {
+// var hexstring vl_hs :='FE'H
+// if(hex2bit(vl_hs)=='11111111'B){
+// setverdict(pass);
+// } else {
+// setverdict(fail);
+// }
+//}
+
+testcase tc_predef_hex2bit_good1() runs on CT {
+ var RoHS vl_hexaValues := {
+ '0'H,'1'H,'2'H,'3'H,'4'H,
+ '5'H,'6'H,'7'H,'8'H,'9'H,
+ 'A'H,'B'H,'C'H,'D'H,'E'H,'F'H
+ }
+ var RoBS vl_expectedValues := {
+ '0000'B,'0001'B,'0010'B,'0011'B,'0100'B,
+ '0101'B,'0110'B,'0111'B,'1000'B,'1001'B,
+ '1010'B,'1011'B,'1100'B,'1101'B,'1110'B,'1111'B
+ }
+ var integer N := sizeof(vl_hexaValues);
+ for(var integer i:=0;i<N;i:=i+1){
+ if(hex2bit(vl_hexaValues[i])==vl_expectedValues[i]){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ //log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2bit(vl_hexaValues[i]))
+ }
+}
+
+testcase tc_predef_hex2bit_good2() runs on CT{
+ var RoHS vl_hexaValues := {'01'H,'0A'H,'FF'H}
+ var RoBS vl_expectedValues := {'00000001'B,'0000 1010'B,'11111111'B}
+ var integer N := sizeof(vl_hexaValues);
+ for(var integer i:=0;i<N;i:=i+1){
+ if(hex2bit(vl_hexaValues[i])==vl_expectedValues[i]){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2bit(vl_hexaValues[i]))
+ }
+}
+
+testcase tc_predef_hex2bit_good20() runs on CT {
+ var hexstring vl_hs :='ABBA9'H
+ if(hex2bit(vl_hs)=='10101011101110101001'B){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+//hexstring element in the arg
+testcase tc_predef_hex2bit_hexstr_element() runs on CT {
+ var hexstring vl_hs :='ABBA9'H
+ var bitstring vl_bs := '10101011101110101001'B
+ var integer N := lengthof(vl_hs);
+ for(var integer i:=0;i<N;i:=i+1){
+ if(hex2bit(vl_hs[i])==substr(vl_bs,i*4,4)){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ log(vl_hs[i],"->",hex2bit(vl_hs[i])," expected: ",substr(vl_bs,i*4,4));
+ }
+}
+//===== hex2int ====
+testcase tc_predef_hex2int_unbound() runs on CT {
+ var hexstring vl_hs;
+ @try {
+ if(hex2int(vl_hs)==0){
+ setverdict(fail,"DTE expected");
+ } else {
+ setverdict(fail,"DTE expected");
+ }
+ }@catch(e){
+ setverdict(pass, "Expected DTE catched")
+ }
+}
+
+testcase tc_predef_hex2int_empty() runs on CT {
+ var hexstring vl_hs:=''H;
+ if(hex2int(vl_hs)==0){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_hex2int_good1() runs on CT {
+ var RoHS vl_hexaValues := {
+ '0'H,'1'H,'2'H,'3'H,'4'H,
+ '5'H,'6'H,'7'H,'8'H,'9'H,
+ 'A'H,'B'H,'C'H,'D'H,'E'H,'F'H
+ }
+ var RoI vl_expectedValues := {
+ 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
+ }
+ var integer N := sizeof(vl_hexaValues);
+ for(var integer i:=0;i<N;i:=i+1){
+ if(hex2int(vl_hexaValues[i])==vl_expectedValues[i]){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2int(vl_hexaValues[i]))
+ }
+}
+
+testcase tc_predef_hex2int_good2() runs on CT{
+ var RoHS vl_hexaValues := {'01'H,'0A'H,'FF'H,'ABBA9'H}
+ var RoI vl_expectedValues := {1,10,255,703401}
+ var integer N := sizeof(vl_hexaValues);
+ for(var integer i:=0;i<N;i:=i+1){
+ if(hex2int(vl_hexaValues[i])==vl_expectedValues[i]){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2int(vl_hexaValues[i]))
+ }
+}
+
+testcase tc_predef_hex2int_good3() runs on CT {
+ var hexstring vl_hs :='0123456789ABCDEF'H
+ if(hex2int(vl_hs)==81985529216486895){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+//hexstring element in the arg
+testcase tc_predef_hex2int_hexstr_element() runs on CT {
+ var hexstring vl_hs :='019ABBAF'H
+ var RoI int_list :={0,1,9,10,11,11,10,15}
+ var integer N := lengthof(vl_hs);
+ for(var integer i:=0;i<N;i:=i+1){
+ if (hex2int(vl_hs[i])==int_list[i]) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ log(vl_hs[i],"->",hex2bit(vl_hs[i])," expected: ",int_list[i]);
+ }
+}
+//===== hex2oct =====
+testcase tc_predef_hex2oct_empty1() runs on CT {
+ if(hex2oct(''H)==''O) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_hex2oct_empty2() runs on CT {
+ var hexstring vl_hs :=''H
+ if(hex2oct(vl_hs)==''O){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+testcase tc_predef_hex2oct_unbound() runs on CT {
+ var hexstring vl_hs;
+ @try {
+ if(hex2oct(vl_hs)==''O){
+ setverdict(fail,"DTE expected");
+ } else {
+ setverdict(fail,"DTE expected");
+ }
+ }@catch(e){
+ setverdict(pass, "Expected DTE catched")
+ }
+}
+
+
+testcase tc_predef_hex2oct_good1() runs on CT {
+ var RoHS vl_hexaValues := {
+ '0'H,'1'H,'2'H,'3'H,'4'H,
+ '5'H,'6'H,'7'H,'8'H,'9'H,
+ 'A'H,'B'H,'C'H,'D'H,'E'H,'F'H
+ }
+ var RoOS vl_expectedValues := {
+ '00'O,'01'O,'02'O,'03'O,'04'O,
+ '05'O,'06'O,'07'O,'08'O,'09'O,
+ '0A'O,'0B'O,'0C'O,'0D'O,'0E'O,'0F'O
+ }
+ var integer N := sizeof(vl_hexaValues);
+ for(var integer i:=0;i<N;i:=i+1){
+ if(hex2oct(vl_hexaValues[i])==vl_expectedValues[i]){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2oct(vl_hexaValues[i]))
+ }
+}
+
+testcase tc_predef_hex2oct_good2() runs on CT{
+ var RoHS vl_hexaValues := {'01'H,'0A'H,'EF'H, 'FF'H}
+ var RoOS vl_expectedValues := {'01'O,'0A'O, 'EF'O, 'FF'O}
+ var integer N := sizeof(vl_hexaValues);
+ for(var integer i:=0;i<N;i:=i+1){
+ if(hex2oct(vl_hexaValues[i])==vl_expectedValues[i]){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2oct(vl_hexaValues[i]))
+ }
+}
+//literal 1
+testcase tc_predef_hex2oct_good3() runs on CT{
+ if(hex2oct('4'H)=='04'O){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+//literal 2
+testcase tc_predef_hex2oct_good4() runs on CT{
+ if(hex2oct('00FF'H)=='00FF'O){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+//literal 3
+testcase tc_predef_hex2oct_good5() runs on CT{
+ if(hex2oct('0FF'H)=='00FF'O){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+//padding expected, runtime
+testcase tc_predef_hex2oct_good6() runs on CT{
+ var hexstring vl_hs := '0FF'H
+ if(hex2oct(vl_hs)=='00FF'O){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_hex2oct_good7() runs on CT {
+ var hexstring vl_hs :='ABBA9'H
+ if(hex2oct(vl_hs)=='0ABBA9'O){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+//hexstring element in the arg
+testcase tc_predef_hex2oct_hexstr_element() runs on CT {
+ var hexstring vl_hs :='ABBA9'H
+ var RoOS vl_bs := { '0A'O,'0B'O,'0B'O,'0A'O,'09'O}
+ var integer N := lengthof(vl_hs);
+ for(var integer i:=0;i<N;i:=i+1){
+ if(hex2oct(vl_hs[i])==vl_bs[i]){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ log(vl_hs[i],"->",hex2oct(vl_hs[i])," expected: ",vl_bs[i]);
+ }
+}
+
+//=========hex2str=============
+//C.1.20 Hexstring to charstring
+//Example: hex2str('AB801'H) // will return "AB801"
+
+testcase tc_predef_hex2str_empty1() runs on CT {
+ var hexstring vl_hs :=''H
+ if(hex2str(vl_hs)==""){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+testcase tc_predef_hex2str_unbound() runs on CT {
+ var hexstring vl_hs;
+ @try {
+ if(hex2str(vl_hs)==""){
+ setverdict(fail,"DTE expected");
+ } else {
+ setverdict(fail,"DTE expected");
+ }
+ setverdict(fail, "This line should not be reached");
+ }@catch(e){
+ setverdict(pass, "Expected DTE catched")
+ }
+}
+
+testcase tc_predef_hex2str_good1() runs on CT {
+ var RoHS vl_hexaValues := {
+ '0'H,'1'H,'2'H,'3'H,'4'H,
+ '5'H,'6'H,'7'H,'8'H,'9'H,
+ 'A'H,'B'H,'C'H,'D'H,'E'H,'F'H
+ }
+ var RoCS vl_expectedValues := {
+ "0","1","2","3","4",
+ "5","6","7","8","9",
+ "A","B","C","D","E","F"
+ }
+ var integer N := sizeof(vl_hexaValues);
+ for(var integer i:=0;i<N;i:=i+1){
+ if(hex2str(vl_hexaValues[i])==vl_expectedValues[i]){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2str(vl_hexaValues[i]))
+ }
+}
+
+testcase tc_predef_hex2str_good2() runs on CT{
+ var RoHS vl_hexaValues := {'01'H,'0A'H,'EF'H, 'FF'H}
+ var RoCS vl_expectedValues := {"01","0A", "EF", "FF"}
+ var integer N := sizeof(vl_hexaValues);
+ for(var integer i:=0;i<N;i:=i+1){
+ if(hex2str(vl_hexaValues[i])==vl_expectedValues[i]){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ log(vl_hexaValues[i],"->expected:",vl_expectedValues[i]," got:",hex2str(vl_hexaValues[i]))
+ }
+}
+
+//literal 1 (compiler time evaluation)
+testcase tc_predef_hex2str_good3() runs on CT{
+ if(hex2str('4'H)=="4"){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+//literal 2
+testcase tc_predef_hex2str_good4() runs on CT{
+ if(hex2str('00FF'H)=="00FF"){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+testcase tc_predef_hex2str_good5() runs on CT{
+ if(hex2str('0FF'H)=="0FF"){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+//no padding
+testcase tc_predef_hex2str_good6() runs on CT{
+ var hexstring vl_hs := '0FF'H
+ if(hex2str(vl_hs)=="0FF"){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+//longer
+testcase tc_predef_hex2str_good7() runs on CT {
+ var hexstring vl_hs :='0123456789ABBAF'H
+ if(hex2str(vl_hs)=="0123456789ABBAF"){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ log(vl_hs,"->",hex2str(vl_hs))
+}
+
+
+//hexstring element
+testcase tc_predef_hex2str_hexstring_element() runs on CT {
+ var hexstring vl_hs :='ABBA9'H
+ var RoCS vl_bs := { "A","B","B","A","9"}
+ var integer N := lengthof(vl_hs);
+ for(var integer i:=0;i<N;i:=i+1){
+ if(hex2str(vl_hs[i])==vl_bs[i]){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ log(vl_hs[i],"->",hex2str(vl_hs[i])," expected: ",vl_bs[i]);
+ }
+}
+
+//int2bit
+testcase tc_predef_int2bit_unbound() runs on CT {
+ var integer vl_i;
+ @try {
+ var bitstring vl_bs := int2bit(vl_i,2);
+ setverdict(fail, "DTE expected");
+ } @catch(e){
+ setverdict(pass,"DTE catched");
+ }
+}
+
+testcase tc_predef_int2bit_wrongLength() runs on CT {
+ var integer vl_i:= 4;
+ @try {
+ var bitstring vl_bs := int2bit(vl_i,2); //too small
+ setverdict(fail, "DTE expected:");
+ } @catch(e){
+ setverdict(pass,"DTE catched");
+ }
+}
+
+testcase tc_predef_int2bit_negLength() runs on CT {
+ var integer vl_i:= 4;
+ var integer len := -1;
+ @try {
+ var bitstring vl_bs := int2bit(vl_i,len);
+ setverdict(fail, "DTE expected:");
+ } @catch(e){
+ setverdict(pass,"DTE catched");
+ }
+}
+
+testcase tc_predef_int2bit_negInt() runs on CT {
+ var integer vl_i:= -4;
+ var integer len := 4;
+ @try {
+ var bitstring vl_bs := int2bit(vl_i,len);
+ setverdict(fail, "DTE expected:");
+ } @catch(e){
+ setverdict(pass,"DTE catched");
+ }
+}
+
+testcase tc_predef_int2bit_good1() runs on CT {
+ var RoBS vl_expectedList := {'00000'B, '00001'B,'00010'B, '00011'B,'00100'B,'00101'B,
+ '00110'B,'00111'B,'01000'B,'01001'B,'01010'B, '10000'B, '10001'B
+ }
+ var RoI vl_intList := {0,1,2,3,4,5,6,7,8,9,10,16,17}
+ var integer N := sizeof(vl_intList);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(int2bit(vl_intList[i],5) != vl_expectedList[i]){
+ setverdict(fail, "expected:", vl_expectedList[i]," got:", int2bit(vl_intList[i],5) );
+ }
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_int2bit_good2() runs on CT {
+ var RoBS vl_expectedList := {'011111111'B,'100000000'B}
+ var RoI vl_intList := {255,256}
+ var integer N := sizeof(vl_intList);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(int2bit(vl_intList[i],9) != vl_expectedList[i]){
+ setverdict(fail, "expected:", vl_expectedList[i]," got:", int2bit(vl_intList[i],9) );
+ }
+ }
+ setverdict(pass);
+}
+
+
+testcase tc_predef_int2bit_good3() runs on CT {
+ var RoBS vl_expectedList := {'0111111110000'B,'1000000000000'B
+ }
+ var RoI vl_intList := {255*16,256*16}
+ var integer N := sizeof(vl_intList);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(int2bit(vl_intList[i],9+4) != vl_expectedList[i]){
+ setverdict(fail, "expected:", vl_expectedList[i]," got:", int2bit(vl_intList[i],9+4) );
+ }
+ }
+ setverdict(pass);
+}
+//==== int2char ======
+testcase tc_predef_int2char_good() runs on CT {
+ var RoCS vl_cslist := { "a","b", "z", "A","Z", "0","1", "9"," ","!", "\"","~","\n","\b","\t","\f","\r"}
+ var RoI vl_intList := { 97, 98, 122, 65, 90, 48,49,57, 32, 33, 34,126,10,8,9,12,13}
+ var integer N := sizeof(vl_cslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(int2char(vl_intList[i])!=vl_cslist[i]){
+ setverdict(fail, "expected (i=",i,") ", vl_cslist[i]," got:", int2char(vl_intList[i]));
+ }
+ // log("expected (i=",i,") ", vl_cslist[i]," got:", int2char(vl_intList[i]))
+ }
+ setverdict(pass);
+}
+testcase tc_predef_int2char_list() runs on CT {
+ var charstring vl_c :="";
+ for(var integer i:=0;i<128; i:=i+1){
+ vl_c := int2char(i);
+ // log(int2char(i));
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_int2char_bad1() runs on CT {
+ var integer i := 128;
+ @try {
+ var charstring vl_cs := int2char(i)
+ setverdict(fail, "Not expected to reach this line, DTE expected")
+ } @catch(e){
+ setverdict(pass, "DTE catched")
+ }
+}
+
+testcase tc_predef_int2char_bad2() runs on CT {
+ var integer i := -1;
+ @try {
+ var charstring vl_cs := int2char(i)
+ setverdict(fail, "Not expected to reach this line, DTE expected")
+ } @catch(e){
+ setverdict(pass, "DTE catched")
+ }
+}
+
+//===int2enum===
+//see: enumOper
+
+//==== int2float =====
+testcase tc_predef_int2float_good1() runs on CT {
+ var RoI vl_intlist := {1,-123,0,1,2,3,4,5,-600, 71250000000, 4294967296,9000000, 123000000000000000 }
+ var RoF vl_floatlist :={1.0,-123.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, -600.0, 7.125e+10, 4294967296.0, 9000000.0, 1.23e+17}
+ var integer N := sizeof( vl_intlist );
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(int2float(vl_intlist[i])!=vl_floatlist[i]){
+ setverdict(fail);
+ }
+ // log((int2float(vl_intlist[i])));
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_int2float_good2() runs on CT {
+ const integer c_10e12 := 1000*1000*1000*1000;
+ var RoI vl_intlist := {c_10e12, c_10e12*c_10e12, c_10e12*c_10e12*c_10e12}
+ var RoF vl_floatlist :={ 1.0e+12, 1e24,1.0e36}
+ var integer N := sizeof( vl_intlist );
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(int2float(vl_intlist[i])!=vl_floatlist[i]){
+ setverdict(fail);
+ }
+ // log((int2float(vl_intlist[i])));
+ }
+ setverdict(pass);
+}
+
+//==== int2hex ====
+
+testcase tc_predef_int2hex_good1() runs on CT {
+ var RoI vl_intlist := {0,1,123, 600, 703401 }
+ var RoHS vl_hexlist :={'00000'H,'00001'H,'0007B'H,'00258'H, 'ABBA9'H}
+ var integer N := sizeof( vl_intlist );
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(int2hex(vl_intlist[i],5)!=vl_hexlist[i]){
+ setverdict(fail);
+ }
+ // log((int2hex(vl_intlist[i],5)));
+ }
+ setverdict(pass);
+}
+
+//neg integer to be converted
+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")
+ }
+}
+
+//too small length
+testcase tc_predef_int2hex_bad2() runs on CT {
+ var integer i := 600;
+ var integer len := 2;
+ @try {
+ var hexstring vl_cs := int2hex(i,len)
+ setverdict(fail, "Not expected to reach this line, DTE expected")
+ } @catch(e){
+ setverdict(pass, "DTE catched")
+ }
+}
+
+// too small length 2
+testcase tc_predef_int2hex_bad3() runs on CT {
+ var integer i := 703401; // 'ABBA9'H
+ var integer len := 4;
+ @try {
+ var hexstring vl_cs := int2hex(i,len)
+ setverdict(fail, "Not expected to reach this line, DTE expected")
+ } @catch(e){
+ setverdict(pass, "DTE catched")
+ }
+}
+
+//negative length
+testcase tc_predef_int2hex_bad4() runs on CT {
+ var integer i := 703401; //'ABBA9'H
+ var integer len := -4;
+ @try {
+ var hexstring vl_cs := int2hex(i,len)
+ 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);
+}
+
+//negative integer to be converted
+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")
+ }
+}
+
+//to small length 1
+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")
+ }
+}
+//to small length 2
+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")
+ }
+}
+//to small length 3
+testcase tc_predef_int2oct_bad4() runs on CT {
+ var integer i := 2147483648; //->'8000 0000'O, len = 4
+ @try {
+ var octetstring vl_cs := int2oct(i,3)
+ setverdict(fail, "Not expected to reach this line, DTE expected")
+ } @catch(e){
+ setverdict(pass, "DTE catched")
+ }
+}
+
+//negative length
+testcase tc_predef_int2oct_bad5() runs on CT {
+ var integer i := 2147483648; //->'8000 0000'O, len = 4
+ var integer len := -1;
+ @try {
+ var octetstring vl_cs := int2oct(i,len)
+ setverdict(fail, "Not expected to reach this line, DTE expected")
+ } @catch(e){
+ setverdict(pass, "DTE catched")
+ }
+}
+
+//int2str
+testcase tc_predef_int2str_good1() runs on CT {
+ var RoI vl_intlist := {0,1,123, 600, 703401,-703401}
+ var RoCS vl_strlist :={"0","1","123","600","703401","-703401"}
+ var integer N := sizeof( vl_intlist );
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(int2str(vl_intlist[i])!=vl_strlist[i]){
+ setverdict(fail);
+ }
+ // log((int2str(vl_intlist[i])));
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_int2str_good2() runs on CT {
+ var RoI vl_intlist := {0,c_2e31/8,c_2e31/2,c_2e31 /*first BigInteger - ok*/,
+ 1*c_2e32-1,1*c_2e32,123*c_2e32, 600*c_2e32, 703401*c_2e32 }
+ var RoCS vl_strlist :={
+ "0",
+ "268435456",
+ "1073741824",
+ "2147483648",
+ "4294967295",
+ "4294967296",
+ "528280977408",
+ "2576980377600",
+ "3021084290973696"
+ }
+ var integer N := sizeof( vl_intlist );
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(int2str(vl_intlist[i])!=vl_strlist[i]){
+ setverdict(fail,"expected: ", vl_strlist[i]," got: ",int2str(vl_intlist[i]));
+ }
+ // log((int2str(vl_intlist[i])));
+ }
+ setverdict(pass);
+}
+//int2unichar
+testcase tc_predef_int2unichar_good1() runs on CT {
+ var RoI vl_intlist := {0,1,123, 600, 703401}
+ var RoUCS vl_strlist :={char(0,0,0,0),char(0,0,0,1),"{",char(0,0,2,88),char(0,10,187,169)}
+ var integer N := sizeof( vl_intlist );
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(int2unichar(vl_intlist[i])!=vl_strlist[i]){
+ setverdict(fail,i);
+ }
+ // log((int2unichar(vl_intlist[i])));
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_int2unichar_good2() runs on CT {
+ var RoI vl_intlist := {0,c_2e31/8,c_2e31/2, c_2e31-1}
+ var RoUCS vl_strlist :={
+ char(0, 0, 0, 0),
+ char(16, 0, 0, 0),
+ char(64, 0, 0, 0),
+ char(127,255,255,255)
+ }
+ var integer N := sizeof( vl_intlist );
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(int2unichar(vl_intlist[i])!=vl_strlist[i]){
+ setverdict(fail,"expected: ", vl_strlist[i]," got: ",int2unichar(vl_intlist[i]));
+ }
+ // log((int2unichar(vl_intlist[i])));
+ }
+ setverdict(pass);
+}
+
+
+testcase tc_predef_int2unichar_bad1() runs on CT {
+ var integer vl_i := -1;
+ var universal charstring vl_cs;
+ @try {
+ vl_cs := int2unichar(vl_i);
+ setverdict(fail, "exception was expected but got:",vl_cs)
+
+ } @catch(e) {
+ setverdict(pass, "exception catched")
+ }
+}
+
+testcase tc_predef_int2unichar_bad2() runs on CT {
+ var integer vl_i := c_2e31 /*first BigInteger - ok*/;
+ var universal charstring vl_cs;
+ @try {
+ vl_cs := int2unichar(vl_i);
+ setverdict(fail, "exception was expected but got:",vl_cs)
+
+ } @catch(e) {
+ setverdict(pass, "exception catched")
+ }
+}
+
+testcase tc_predef_int2unichar_bad3() runs on CT {
+ var integer vl_i := 703401*c_2e32;
+ var universal charstring vl_cs;
+ @try {
+ vl_cs := int2unichar(vl_i);
+ setverdict(fail, "exception was expected but got:",vl_cs)
+
+ } @catch(e) {
+ setverdict(pass, "exception catched")
+ }
+}
+//===== oct2bit =====
+testcase tc_predef_oct2bit_good() runs on CT {
+ var RoBS vl_bslist := {
+ '00000000'B, '0000 0001'B,'0000 0000 0000 0001'B,'0000 0010'B, '0000 0011'B,
+ '0000 0100'B,'0000 0101'B,'0000 0110'B,'0000 0111'B,'0000 1000'B,
+ '0000 1001'B,'0000 1010'B, '0001 0000'B, '0001 0001'B, '0000 0000 0000 0000 0001 0001'B,
+ '1010 1011 1100 1101 1110 1111'B
+ }
+ var RoOS vl_oslist := {
+ '00'O,'01'O,'0001'O,'02'O,'03'O,
+ '04'O,'05'O,'06'O,'07'O,'08'O,
+ '09'O,'0A'O,'10'O,'11'O,'00 00 11'O,
+ 'AB CD EF'O
+ }
+ var integer N := sizeof(vl_oslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(oct2bit(vl_oslist[i])!=vl_bslist[i]){
+ setverdict(fail, "expected (i=",i,") ", vl_bslist[i]," got:", oct2bit(vl_oslist[i]));
+ }
+ log(oct2bit(vl_oslist[i]))
+ }
+ setverdict(pass);
+}
+
+//===== oct2char =======
+//1. "The input parameter invalue shall not contain octet values higher than 7F."
+//2. "The resulting charstring shall have the same length as the input octetstring."
+
+testcase tc_predef_oct2char_good1() runs on CT {
+ var charstring cs := "Dipsy";
+ var octetstring os := '4469707379'O;
+ if( oct2char(os) == cs) {
+ setverdict(pass)
+ } else {
+ setverdict(fail);
+ }
+ log(oct2char(os), " Dipsy");
+ var RoOS vl_oslist := { '44'O,'61'O,'62'O,'7A'O, '41'O, '5A'O,'30'O,'31'O,'39'O,'20'O,'21'O, '22'O, '5C'O,'7E'O }
+ var RoCS vl_cslist := {"D","a","b", "z", "A","Z", "0","1", "9"," ","!", "\"", "\\","~" }
+
+ var integer N := sizeof(vl_oslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(oct2char(vl_oslist[i])!=vl_cslist[i]){
+ setverdict(fail, "expected (i=",i,") ", vl_cslist[i]," got:", oct2char(vl_oslist[i]));
+ } else {
+ setverdict(pass);
+ }
+ log(oct2char(vl_oslist[i]))
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_oct2char_good2() runs on CT {
+ var RoOS vl_oslist := {
+ '00'O,'01'O,'02'O,'03'O,
+ '04'O,'05'O,'06'O,'07'O,'08'O,
+ '09'O,'0A'O,'0b'O,'0C'O, '0d'O,'0e'O,'0f'O,
+ '10'O, '11'O,'12'O,'13'O
+ }
+ var integer N := sizeof(vl_oslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(oct2char(vl_oslist[i])!= int2char(i)) {
+ setverdict(fail, "expected (i=",i,") ",int2char(i)," got:", oct2char(vl_oslist[i]));
+ }
+ // log(oct2char(vl_oslist[i]))
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_oct2char_bad1() runs on CT {
+ var charstring vl_cs;
+ var octetstring vl_os := '80'O;
+ @try {
+ vl_cs := oct2char(vl_os);
+ setverdict(fail, "exception was expected but got:",vl_cs)
+ } @catch(e) {
+ setverdict(pass, "exception catched")
+ }
+}
+
+testcase tc_predef_oct2char_bad2() runs on CT {
+ var charstring vl_cs;
+ var octetstring vl_os := 'AF'O;
+ @try {
+ vl_cs := oct2char(vl_os);
+ setverdict(fail, "exception was expected but got:",vl_cs)
+ } @catch(e) {
+ setverdict(pass, "exception catched")
+ }
+}
+
+testcase tc_predef_oct2char_bad3() runs on CT {
+ var charstring vl_cs;
+ var octetstring vl_os := 'FF'O;
+ @try {
+ vl_cs := oct2char(vl_os);
+ setverdict(fail, "exception was expected but got:",vl_cs)
+ } @catch(e) {
+ setverdict(pass, "exception catched")
+ }
+}
+
+//octetstring element is the argument
+testcase tc_predef_oct2char_octetstr_elem() runs on CT {
+ var charstring cs := "Dipsy";
+ var octetstring os := '4469707379'O;
+ var integer N := lengthof(os);
+ for( var integer i:=0;i<N;i:=i+1){
+ if (oct2char(os[i]) == cs[i]) {
+ setverdict(pass, os[i],"->",oct2char(os[i])," expected: ", cs[i] )
+ } else {
+ setverdict(fail, os[i],"->",oct2char(os[i])," expected: ", cs[i] )
+ }
+ }
+}
+
+//octetstring element is the argument
+testcase tc_predef_oct2char_octetstr_elem_bad() runs on CT {
+ var charstring cs := "Ãá";
+ var octetstring os := 'C1E1'O; //>'7f'O 2x
+ var integer N := lengthof(os);
+ for( var integer i:=0;i<N;i:=i+1){
+ @try {
+ if (oct2char(os[i]) == cs[i]) {
+ log( os[i],"->",oct2char(os[i])," expected: ", cs[i] );
+ } else {
+ log( os[i],"-->",oct2char(os[i])," expected: ", cs[i] );
+ }
+ setverdict(fail, "This line should not be reached");
+ }@catch(e){
+ setverdict(pass, "Expected DTE: ", e);
+ }
+ }
+}
+//===== oct2hex ======
+
+testcase tc_predef_oct2hex_good1() runs on CT {
+ var RoOS vl_oslist := {
+ '00'O,'01'O,'0001'O,'02'O,'03'O,
+ '04'O,'05'O,'06'O,'07'O,'08'O,
+ '08'O,'09'O,'0A'O,'10'O,'11'O,
+ '00 00 11'O,'1A'O,'7F'O, '30 31 32 33 39 3A 3B 7e 60'O, 'ABBA'O, ''O
+ }
+ var RoHS vl_cslist := {
+ '00'H,'01'H,'0001'H,'02'H,'03'H,
+ '04'H,'05'H,'06'H,'07'H,'08'H,
+ '08'H,'09'H,'0A'H,'10'H,'11'H,
+ '00 00 11'H,'1A'H,'7F'H, '30 31 32 33 39 3A 3B 7e 60'H,'ABBA'H,''H
+ }
+ var integer N := sizeof(vl_oslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(oct2hex(vl_oslist[i])!=vl_cslist[i]){
+ setverdict(fail, "expected (i=",i,") ", vl_cslist[i]," got:", oct2hex(vl_oslist[i]));
+ }
+ // log(oct2hex(vl_oslist[i]))
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_oct2hex_good2() runs on CT {
+ var octetstring vl_oslist := '00010203040506070808090a10111a7fFF'O;
+
+ var RoHS vl_cslist := {
+ '00'H,'01'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,
+ '1A'H,'7F'H,'FF'H
+ }
+ var integer N := lengthof(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]));
+ } else {
+ setverdict(pass,"expected (i=",i,") ", vl_cslist[i]," got:", oct2hex(vl_oslist[i]))
+ }
+ // log(oct2hex(vl_oslist[i]))
+ }
+ setverdict(pass);
+}
+//oct2int
+testcase tc_predef_oct2int_good1() runs on CT {
+ var RoOS vl_oslist := {
+ '00'O,'01'O,'0001'O,'02'O,'03'O,
+ '04'O,'05'O,'06'O,'07'O,'08'O,
+ '09'O,'0A'O,'10'O,'11'O,
+ '00 00 11'O,'1A'O,'7F'O,'ABBA'O, 'FFFF FFFF'O, '01 0000 0000'O
+ }
+ var RoI vl_intlist := {
+ 0,1,1,2,3,4,5,6,7,8,9,
+ 10,16,17,17,26,127,43962, 4294967295, 4294967296
+ }
+ var integer N := sizeof(vl_oslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(oct2int(vl_oslist[i])!=vl_intlist[i]){
+ setverdict(fail, "expected (i=",i,") ", vl_intlist[i]," got:", oct2int(vl_oslist[i]));
+ }
+ // log(oct2int(vl_oslist[i]))
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_oct2int_good1a() runs on CT {
+ var octetstring vl_os := '30 31 32 33 39 3A 3B 7e 60'O;
+ var integer vl_i := 888988667715635609184;
+ if(oct2int(vl_os) != vl_i) {
+ setverdict(fail,"expected:", vl_i, " got: ", oct2int(vl_os));
+ } else {
+ setverdict(pass);
+ }
+}
+
+testcase tc_predef_oct2int_good1b() runs on CT {
+ var octetstring vl_os := '10 0000 0000 0000 0000'O;
+ var integer vl_i := 16*65536*65536*65536*65536;
+ if(oct2int(vl_os) != vl_i) {
+ setverdict(fail,"expected:", vl_i, " got: ", oct2int(vl_os));
+ } else {
+ setverdict(pass,"expected:", vl_i, " got: ", oct2int(vl_os));
+ }
+}
+
+testcase tc_predef_oct2int_good2() runs on CT {
+ const RoOS vl_oslist := {
+ '00'O,'01'O,'0001'O,'02'O,'03'O,
+ '04'O,'05'O,'06'O,'07'O,'08'O,
+ '09'O,'0A'O,'10'O,'11'O,
+ '00 00 11'O,'1A'O,'7F'O, '30 31 32 33 39 3A 3B 7e 60'O, 'ABBA'O
+ }
+ var RoI vl_intlist := {
+ 0,1,1,2,3,4,5,6,7,8,9,
+ 10,16,17,17,26,127,888988667715635609184,43962
+ }
+ var integer N := sizeof(vl_oslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(oct2int(vl_oslist[i])!=vl_intlist[i]){
+ setverdict(fail, "expected (i=",i,") ", vl_intlist[i]," got:", oct2int(vl_oslist[i]));
+ }
+ // log(oct2int(vl_oslist[i]))
+ }
+ setverdict(pass);
+}
+
+
+
+testcase tc_predef_oct2int_empty() runs on CT {
+ var integer vl_i;
+ var octetstring vl_os := ''O;
+ if (oct2int(vl_os)!= 0) {
+ setverdict(fail,"expected 0")
+ } else {
+ setverdict(pass)
+ }
+}
+
+//oct2str
+//C.1.24 Octetstring to character string
+//oct2str('4469707379'O) = "4469707379"
+testcase tc_predef_oct2str_good1() runs on CT {
+ var RoOS vl_oslist := {
+ '00'O,'01'O,'0001'O,'02'O,'03'O,
+ '04'O,'05'O,'06'O,'07'O,'08'O,
+ '08'O,'09'O,'0A'O,'10'O,'11'O,
+ '00 00 11'O,'1A'O,'7F'O, '30 31 32 33 39 3A 3B 7e 60'O, 'ABBA'O, ''O
+ }
+ var RoCS vl_cslist := {
+ "00","01","0001","02","03",
+ "04","05","06","07","08",
+ "08","09","0A","10","11",
+ "000011","1A","7F", "30313233393A3B7E60","ABBA",""
+ }
+ var integer N := sizeof(vl_oslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(oct2str(vl_oslist[i])!=vl_cslist[i]){
+ setverdict(fail, "expected (i=",i,") ", vl_cslist[i]," got:", oct2str(vl_oslist[i]));
+ }
+ // log(oct2str(vl_oslist[i]))
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_oct2str_good2() runs on CT {
+ const RoOS vl_oslist := {
+ '00'O,'01'O,'0001'O,'02'O,'03'O,
+ '04'O,'05'O,'06'O,'07'O,'08'O,
+ '08'O,'09'O,'0A'O,'10'O,'11'O,
+ '00 00 11'O,'1A'O,'7F'O, '30 31 32 33 39 3A 3B 7e 60'O, 'ABBA'O, ''O
+ }
+ var RoCS vl_cslist := {
+ "00","01","0001","02","03",
+ "04","05","06","07","08",
+ "08","09","0A","10","11",
+ "000011","1A","7F", "30313233393A3B7E60","ABBA",""
+ }
+ var integer N := sizeof(vl_oslist);
+ for(var integer i:=0;i<N; i:=i+1){
+ if(oct2str(vl_oslist[i])!=vl_cslist[i]){
+ setverdict(fail, "expected (i=",i,") ", vl_cslist[i]," got:", oct2str(vl_oslist[i]));
+ }
+ // log(oct2str(vl_oslist[i]))
+ }
+ setverdict(pass);
+}
+
+//for octetstring elements
+testcase tc_predef_oct2str_octetstring_element() runs on CT {
+ var octetstring vl_os :='ABBA09'O
+ var RoCS vl_cs := { "AB","BA","09"}
+ var integer N := lengthof(vl_os);
+ for(var integer i:=0;i<N;i:=i+1){
+ if(oct2str(vl_os[i])==vl_cs[i]){
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ log(vl_os[i],"->",oct2str(vl_os[i])," expected: ",vl_cs[i]);
+ }
+}
+
+//==== universal charstring related functions: see ucharstrOper ===
+
+//================================================
+//============ replace() =========================
+//================================================
+
+//*********** Replace() for bitstring ************
+
+// remove 2 chars from the beginnining, compile time
+testcase tc_predef_replace_bitstring_1() runs on CT {
+ var bitstring vl_bs := replace('0000 1111'B,0,2,''B);
+ if(vl_bs != '00 1111'B){
+ setverdict(fail, "expected '001111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+//var pars
+testcase tc_predef_replace_bitstring_1a() runs on CT {
+ var integer vl_beginning :=0, vl_len := 2;
+ var bitstring vl_bs := replace('0000 1111'B,vl_beginning,vl_len,''B);
+ if(vl_bs != '00 1111'B){
+ setverdict(fail, "expected '001111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+//const pars
+testcase tc_predef_replace_bitstring_1b() runs on CT {
+ const integer vl_beginning :=0, vl_len := 2;
+ var bitstring vl_bs := replace('0000 1111'B,vl_beginning,vl_len,''B);
+ if(vl_bs != '00 1111'B){
+ setverdict(fail, "expected '001111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+// remove 2 chars from the beginnining, run time
+testcase tc_predef_replace_bitstring_2() runs on CT {
+ var bitstring vl_bs0 := '0000 1111'B
+ var bitstring vl_bs := replace(vl_bs0,0,2,''B);
+ if(vl_bs != '00 1111'B){
+ setverdict(fail, "expected '001111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining, run time
+//parameters are variables
+testcase tc_predef_replace_bitstring_2a() runs on CT {
+ var integer vl_beginning :=0, vl_len := 2;
+ var bitstring vl_bs0 := '0000 1111'B
+ var bitstring vl_bs := replace(vl_bs0,vl_beginning,vl_len,''B);
+ if(vl_bs != '00 1111'B){
+ setverdict(fail, "expected '001111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+// remove 2 chars from the beginnining,insert 1 char compile time
+testcase tc_predef_replace_bitstring_3() runs on CT {
+ var bitstring vl_bs := replace('0000 1111'B,0,2,'1'B);
+ if(vl_bs != '100 1111'B){
+ setverdict(fail, "expected '1001111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 1 char runtime
+testcase tc_predef_replace_bitstring_4() runs on CT {
+ var bitstring vl_bs0 := '0000 1111'B
+ var bitstring vl_bs := replace(vl_bs0,0,2,'1'B);
+ if(vl_bs != '100 1111'B){
+ setverdict(fail, "expected '1001111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining,insert 2 char compile time
+testcase tc_predef_replace_bitstring_5() runs on CT {
+ var bitstring vl_bs := replace('0000 1111'B,0,2,'11'B);
+ if(vl_bs != '1100 1111'B){
+ setverdict(fail, "expected '11001111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 2 char runtime
+testcase tc_predef_replace_bitstring_6() runs on CT {
+ var bitstring vl_bs0 := '0000 1111'B
+ var bitstring vl_bs := replace(vl_bs0,0,2,'11'B);
+ if(vl_bs != '1100 1111'B){
+ setverdict(fail, "expected '11001111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining,insert 3 char compile time
+testcase tc_predef_replace_bitstring_7() runs on CT {
+ var bitstring vl_bs := replace('0000 1111'B,0,2,'111'B);
+ if(vl_bs != '11100 1111'B){
+ setverdict(fail, "expected '111001111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 3 char runtime
+testcase tc_predef_replace_bitstring_8() runs on CT {
+ var bitstring vl_bs0 := '0000 1111'B
+ var bitstring vl_bs := replace(vl_bs0,0,2,'111'B);
+ if(vl_bs != '11100 1111'B){
+ setverdict(fail, "expected '111001111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the second char (index position 1), insert 3 char compile time
+testcase tc_predef_replace_bitstring_9() runs on CT {
+ var bitstring vl_bs := replace('0000 1111'B,1,2,'111'B);
+ if(vl_bs != '0 1110 1111'B){
+ setverdict(fail, "expected '011101111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the second char (index position 1), insert 3 char runtime
+testcase tc_predef_replace_bitstring_10() runs on CT {
+ var bitstring vl_bs0 := '0000 1111'B
+ var bitstring vl_bs := replace(vl_bs0,1,2,'111'B);
+ if(vl_bs != '011101111'B){
+ setverdict(fail, "expected '011101111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// append 3 chars compile time
+testcase tc_predef_replace_bitstring_11() runs on CT {
+ var bitstring vl_bs := replace('0000 1111'B,8,0,'011'B);
+ if(vl_bs != '0000 1111 011'B){
+ setverdict(fail, "expected '00001111011'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// append 3 char runtime
+testcase tc_predef_replace_bitstring_12() runs on CT {
+ var bitstring vl_bs0 := '0000 1111'B
+ var bitstring vl_bs := replace(vl_bs0,8,0,'011'B);
+ if(vl_bs != '0000 1111 011'B){
+ setverdict(fail, "expected '00001111011'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//Expected on-the-fly semantic marker:
+//The sum of the second operand (8) and the third operand (1) of operation `replace' is greater than the length of the first operand (8)
+//testcase tc_predef_replace_bitstring_13_bad() runs on CT {
+// var bitstring vl_bs := replace('0000 1111'B,8,1,'011'B);
+//}
+
+//too long index: 8+1
+testcase tc_predef_replace_bitstring_14_bad() runs on CT {
+ var bitstring vl_bs0 := '0000 1111'B
+ @try {
+ var bitstring vl_bs := replace(vl_bs0,8,1,'011'B);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//Expected on-the-fly semantic marker:
+//The sum of the second operand (8) and the third operand (1) of operation `replace' is greater than the length of the first operand (8)
+//testcase tc_predef_replace_bitstring_15_bad() runs on CT {
+// var bitstring vl_bs := replace('0000 1111'B,7,2,'011'B);
+//}
+////Expected on-the-fly semantic marker:
+////The third operand of operation `replace' should not be negative
+//testcase tc_predef_replace_bitstring_15a_bad() runs on CT {
+// var bitstring vl_bs := replace('0000 1111'B,7,-2,'011'B);
+//}
+//testcase tc_predef_replace_bitstring_15b_bad() runs on CT {
+// var bitstring vl_bs := replace('0000 1111'B,7,-2,'11'H);
+//}
+
+//too long index: 7+2
+testcase tc_predef_replace_bitstring_16_bad() runs on CT {
+ var bitstring vl_bs0 := '0000 1111'B
+ @try {
+ var bitstring vl_bs := replace(vl_bs0,7,2,'011'B);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+//too long index: 9+0
+testcase tc_predef_replace_bitstring_18_bad() runs on CT {
+ var bitstring vl_bs0 := '0000 1111'B
+ @try {
+ var bitstring vl_bs := replace(vl_bs0,9,0,'011'B);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//negative index:
+testcase tc_predef_replace_bitstring_19_bad() runs on CT {
+ var bitstring vl_bs0 := '0000 1111'B
+ var integer idx := -1;
+ @try {
+ var bitstring vl_bs := replace(vl_bs0,idx,0,'011'B);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//negative length
+testcase tc_predef_replace_bitstring_20_bad() runs on CT {
+ var bitstring vl_bs0 := '0000 1111'B
+ var integer idx := 0, len := -1;
+ @try {
+ var bitstring vl_bs := replace(vl_bs0,idx,len,'011'B);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+//uninitialized str to be inserted
+testcase tc_predef_replace_bitstring_21_bad() runs on CT {
+ var bitstring vl_bs0 := '0000 1111'B;
+ var bitstring vl_bs1;//uninit!
+ var integer idx := 0, len := 1;
+ @try {
+ var bitstring vl_bs := replace(vl_bs0,idx,len, vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//uninitialized input string
+testcase tc_predef_replace_bitstring_22_bad() runs on CT {
+ var bitstring vl_bs0 ; //uninit!
+ var integer idx := 0, len := 1;
+ @try {
+ var bitstring vl_bs := replace(vl_bs0,idx,len,'011'B);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+// bitstring template
+// remove 2 chars from the beginnining,insert 2 char compile time
+testcase tc_predef_replace_bitstring_23() runs on CT {
+ var template bitstring tl_bs0 := '0000 1111'B;
+ var template bitstring tl_bs1 := '11'B;
+ const integer idx := 0;
+ const integer len := 2
+ var bitstring vl_bs := replace(tl_bs0,idx,len,tl_bs1);
+ if(vl_bs != '1100 1111'B){
+ setverdict(fail, "expected '11001111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+
+// remove 2 chars from the beginnining,insert 2 char runtime
+testcase tc_predef_replace_bitstring_24() runs on CT {
+ template bitstring tl_bs0 := '0000 1111'B;
+ template bitstring tl_bs1 := '11'B;
+ var integer idx := 0;
+ var integer len := 2
+ var bitstring vl_bs := replace(tl_bs0,idx,len,tl_bs1);
+ if(vl_bs != '1100 1111'B){
+ setverdict(fail, "expected '11001111'B got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+
+//*********** Replace() for hexstring ************
+
+// remove 2 chars from the beginnining, compile time
+testcase tc_predef_replace_hexstring_1() runs on CT {
+ var hexstring vl_bs := replace('0000 1111'H,0,2,''H);
+ if(vl_bs != '00 1111'H){
+ setverdict(fail, "expected '001111'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+//var pars
+testcase tc_predef_replace_hexstring_1a() runs on CT {
+ var integer vl_beginning :=0, vl_len := 2;
+ var hexstring vl_bs := replace('0000 1111'H,vl_beginning,vl_len,''H);
+ if(vl_bs != '00 1111'H){
+ setverdict(fail, "expected '001111'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+//const pars
+testcase tc_predef_replace_hexstring_1b() runs on CT {
+ const integer vl_beginning :=0, vl_len := 2;
+ var hexstring vl_bs := replace('0000 1111'H,vl_beginning,vl_len,''H);
+ if(vl_bs != '00 1111'H){
+ setverdict(fail, "expected '001111'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+// remove 2 chars from the beginnining, run time
+testcase tc_predef_replace_hexstring_2() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ var hexstring vl_bs := replace(vl_bs0,0,2,''H);
+ if(vl_bs != '00 1111'H){
+ setverdict(fail, "expected '001111'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining, run time
+//parameters are variables
+testcase tc_predef_replace_hexstring_2a() runs on CT {
+ var integer vl_beginning :=0, vl_len := 2;
+ var hexstring vl_bs0 := '0000 1111'H
+ var hexstring vl_bs := replace(vl_bs0,vl_beginning,vl_len,''H);
+ if(vl_bs != '00 1111'H){
+ setverdict(fail, "expected '001111'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+// remove 2 chars from the beginnining,insert 1 char compile time
+testcase tc_predef_replace_hexstring_3() runs on CT {
+ var hexstring vl_bs := replace('0000 1111'H,0,2,'1'H);
+ if(vl_bs != '100 1111'H){
+ setverdict(fail, "expected '1001111'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 1 char runtime
+testcase tc_predef_replace_hexstring_4() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ var hexstring vl_bs := replace(vl_bs0,0,2,'1'H);
+ if(vl_bs != '100 1111'H){
+ setverdict(fail, "expected '1001111'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining,insert 2 char compile time
+testcase tc_predef_replace_hexstring_5() runs on CT {
+ var hexstring vl_bs := replace('0000 1111'H,0,2,'11'H);
+ if(vl_bs != '1100 1111'H){
+ setverdict(fail, "expected '11001111'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 2 char runtime
+testcase tc_predef_replace_hexstring_6() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ var hexstring vl_bs := replace(vl_bs0,0,2,'11'H);
+ if(vl_bs != '1100 1111'H){
+ setverdict(fail, "expected '11001111'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining,insert 3 char compile time
+testcase tc_predef_replace_hexstring_7() runs on CT {
+ var hexstring vl_bs := replace('0000 1111'H,0,2,'111'H);
+ if(vl_bs != '11100 1111'H){
+ setverdict(fail, "expected '111001111'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 3 char runtime
+testcase tc_predef_replace_hexstring_8() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ var hexstring vl_bs := replace(vl_bs0,0,2,'111'H);
+ if(vl_bs != '11100 1111'H){
+ setverdict(fail, "expected '111001111'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the second char (index position 1), insert 3 char compile time
+testcase tc_predef_replace_hexstring_9() runs on CT {
+ var hexstring vl_bs := replace('0000 1111'H,1,2,'111'H);
+ if(vl_bs != '0 1110 1111'H){
+ setverdict(fail, "expected '011101111'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the second char (index position 1), insert 3 char runtime
+testcase tc_predef_replace_hexstring_10() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ var hexstring vl_bs := replace(vl_bs0,1,2,'111'H);
+ if(vl_bs != '011101111'H){
+ setverdict(fail, "expected '011101111'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// append 3 chars compile time
+testcase tc_predef_replace_hexstring_11() runs on CT {
+ var hexstring vl_bs := replace('0000 1111'H,8,0,'011'H);
+ if(vl_bs != '0000 1111 011'H){
+ setverdict(fail, "expected '00001111011'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// append 3 char runtime
+testcase tc_predef_replace_hexstring_12() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ var hexstring vl_bs := replace(vl_bs0,8,0,'011'H);
+ if(vl_bs != '0000 1111 011'H){
+ setverdict(fail, "expected '00001111011'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//Expected on-the-fly semantic marker:
+//The sum of the second operand (8) and the third operand (1) of operation `replace' is greater than the length of the first operand (8)
+//testcase tc_predef_replace_hexstring_13_bad() runs on CT {
+// var hexstring vl_bs := replace('0000 1111'H,8,1,'011'H);
+
+//}
+
+//too long index: 8+1
+testcase tc_predef_replace_hexstring_14_bad() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ @try {
+ var hexstring vl_bs := replace(vl_bs0,8,1,'011'H);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//Expected on-the-fly semantic marker:
+//The sum of the second operand (8) and the third operand (1) of operation `replace' is greater than the length of the first operand (8)
+//testcase tc_predef_replace_hexstring_15_bad() runs on CT {
+// var hexstring vl_bs := replace('0000 1111'H,7,2,'011'H);
+//}
+////Expected on-the-fly semantic marker:
+////The third operand of operation `replace' should not be negative
+//testcase tc_predef_replace_hexstring_15a_bad() runs on CT {
+// var hexstring vl_bs := replace('0000 1111'H,7,-2,'011'H);
+//}
+//testcase tc_predef_replace_hexstring_15b_bad() runs on CT {
+// var hexstring vl_bs := replace('0000 1111'H,7,-2,'11'H);
+//}
+
+//too long index: 7+2
+testcase tc_predef_replace_hexstring_16_bad() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ @try {
+ var hexstring vl_bs := replace(vl_bs0,7,2,'011'H);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+//too long index: 9+0
+testcase tc_predef_replace_hexstring_18_bad() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ @try {
+ var hexstring vl_bs := replace(vl_bs0,9,0,'011'H);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//too long index: 7+2, runtime
+testcase tc_predef_replace_hexstring_19() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ var hexstring vl_bs1 := '011'H;
+ var integer idx := 7;
+ var integer len := 2;
+ @try {
+ var hexstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//too long index: 9+0, runtime
+testcase tc_predef_replace_hexstring_20() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ var hexstring vl_bs1 := '011'H;
+ var integer idx := 9;
+ var integer len := 0;
+ @try {
+ var hexstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//negative index
+testcase tc_predef_replace_hexstring_21() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ var hexstring vl_bs1 := '011'H;
+ var integer idx := -1;
+ var integer len := 2;
+ @try {
+ var hexstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//negative length
+testcase tc_predef_replace_hexstring_22() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ var hexstring vl_bs1 := '011'H;
+ var integer idx := 0;
+ var integer len := -2;
+ @try {
+ var hexstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//uninit original string
+testcase tc_predef_replace_hexstring_23() runs on CT {
+ var hexstring vl_bs0;
+ var hexstring vl_bs1 := '011'H;
+ var integer idx := 0;
+ var integer len := 0;
+ @try {
+ var hexstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//uninit string to be inserted
+testcase tc_predef_replace_hexstring_24() runs on CT {
+ var hexstring vl_bs0 := '0000 1111'H
+ var hexstring vl_bs1 ;
+ var integer idx := 0;
+ var integer len := 0;
+ @try {
+ var hexstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+// var templates. append 3 char runtime
+testcase tc_predef_replace_hexstring_25() runs on CT {
+ var template hexstring vl_bs0 := '0000 1111'H
+ var template hexstring vl_bs1 := '011'H;
+ var integer idx := 8;
+ var integer len := 0;
+ var hexstring vl_bs := replace(vl_bs0,idx,len, vl_bs1);
+ if(vl_bs != '0000 1111 011'H){
+ setverdict(fail, "expected '00001111011'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// const local templates. append 3 char runtime
+testcase tc_predef_replace_hexstring_26() runs on CT {
+ template hexstring vl_bs0 := '0000 1111'H
+ template hexstring vl_bs1 := '011'H;
+ var integer idx := 8;
+ var integer len := 0;
+ var hexstring vl_bs := replace(vl_bs0,idx,len, vl_bs1);
+ if(vl_bs != '0000 1111 011'H){
+ setverdict(fail, "expected '00001111011'H got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//*********** Replace() for octetstring **********
+
+// remove 2 chars from the beginnining, compile time
+testcase tc_predef_replace_octetstring_1() runs on CT {
+ var octetstring vl_bs := replace('0000 1111'O,0,1,''O);
+ if(vl_bs != '00 1111'O){
+ setverdict(fail, "expected '001111'O got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//var pars
+testcase tc_predef_replace_octetstring_1a() runs on CT {
+ var integer vl_beginning :=0, vl_len := 1;
+ var octetstring vl_os := replace('0000 1111'O,vl_beginning,vl_len,''O);
+ if(vl_os != '00 1111'O){
+ setverdict(fail, "expected '001111'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+}
+//const pars
+testcase tc_predef_replace_octetstring_1b() runs on CT {
+ const integer vl_beginning :=0, vl_len := 1;
+ var octetstring vl_os := replace('0000 1111'O,vl_beginning,vl_len,''O);
+ if(vl_os != '00 1111'O){
+ setverdict(fail, "expected '001111'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+}
+// remove 2 chars from the beginnining, run time
+testcase tc_predef_replace_octetstring_2() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ var octetstring vl_os := replace(vl_os0,0,1,''O);
+ if(vl_os != '00 1111'O){
+ setverdict(fail, "expected '001111'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining, run time
+//parameters are variables
+testcase tc_predef_replace_octetstring_2a() runs on CT {
+ var integer vl_beginning :=0, vl_len := 1;
+ var octetstring vl_os0 := '0000 1111'O
+ var octetstring vl_os := replace(vl_os0,vl_beginning,vl_len,''O);
+ if(vl_os != '00 1111'O){
+ setverdict(fail, "expected '001111'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+}
+// remove 2 chars from the beginnining,insert 1 char compile time
+testcase tc_predef_replace_octetstring_3() runs on CT {
+ var octetstring vl_os := replace('0000 1111'O,0,1,'11'O);
+ if(vl_os != '1100 1111'O){
+ setverdict(fail, "expected '11001111'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 1 char runtime
+testcase tc_predef_replace_octetstring_4() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ var octetstring vl_os := replace(vl_os0,0,1,'11'O);
+ if(vl_os != '1100 1111'O){
+ setverdict(fail, "expected '11001111'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 4 chars from the beginnining,insert 2 char compile time
+testcase tc_predef_replace_octetstring_5() runs on CT {
+ var octetstring vl_os := replace('0000 1111'O,0,2,'11'O);
+ if(vl_os != '11 1111'O){
+ setverdict(fail, "expected '111111'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 2 char runtime
+testcase tc_predef_replace_octetstring_6() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ var octetstring vl_os := replace(vl_os0,0,2,'11'O);
+ if(vl_os != '11 1111'O){
+ setverdict(fail, "expected '111111'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining,insert 3 char compile time
+testcase tc_predef_replace_octetstring_7() runs on CT {
+ var octetstring vl_os := replace('0000 1111'O,0,2,'1111'O);
+ if(vl_os != '1111 1111'O){
+ setverdict(fail, "expected '11111111'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 3 char runtime
+testcase tc_predef_replace_octetstring_8() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ var octetstring vl_os := replace(vl_os0,0,2,'1111'O);
+ if(vl_os != '1111 1111'O){
+ setverdict(fail, "expected '11111111'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the second char (index position 1), insert 3 char compile time
+testcase tc_predef_replace_octetstring_9() runs on CT {
+ var octetstring vl_os := replace('0000 1111'O,1,2,'1111'O);
+ if(vl_os != '00 1111 11'O){
+ setverdict(fail, "expected '00111111'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the second char (index position 1), insert 3 char runtime
+testcase tc_predef_replace_octetstring_10() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ var octetstring vl_os := replace(vl_os0,1,2,'1111'O);
+ if(vl_os != '00111111'O){
+ setverdict(fail, "expected '00111111'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// append 4 chars compile time
+testcase tc_predef_replace_octetstring_11() runs on CT {
+ var octetstring vl_os := replace('0000 1111'O,4,0,'0011'O);
+ if(vl_os != '0000 1111 0011'O){
+ setverdict(fail, "expected '000011110011'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// append 3 char runtime
+testcase tc_predef_replace_octetstring_12() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ var octetstring vl_os := replace(vl_os0,4,0,'0011'O);
+ if(vl_os != '0000 1111 0011'O){
+ setverdict(fail, "expected '000011110011'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//Expected on-the-fly semantic marker:
+//The sum of the second operand (8) and the third operand (1) of operation `replace' is greater than the length of the first operand (8)
+//testcase tc_predef_replace_octetstring_13_bad() runs on CT {
+// var octetstring vl_os := replace('0000 1111'O,8,1,'011'O);
+
+//}
+
+//too long index: 4+1, perhaps compile time
+testcase tc_predef_replace_octetstring_14_bad() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ @try {
+ var octetstring vl_os := replace(vl_os0,4,1,'0011'O);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//Expected on-the-fly semantic marker:
+//The sum of the second operand (8) and the third operand (1) of operation `replace' is greater than the length of the first operand (8)
+//testcase tc_predef_replace_octetstring_15_bad() runs on CT {
+// var octetstring vl_os := replace('0000 1111'O,3,2,'0011'O);
+//}
+////Expected on-the-fly semantic marker:
+////The third operand of operation `replace' should not be negative
+//testcase tc_predef_replace_octetstring_15a_bad() runs on CT {
+// var octetstring vl_os := replace('0000 1111'O,3,-2,'0011'O);
+//}
+//testcase tc_predef_replace_octetstring_15b_bad() runs on CT {
+// var octetstring vl_os := replace('0000 1111'O,3,-2,'11'O);
+//}
+
+//too long index: 3+2
+testcase tc_predef_replace_octetstring_16_bad() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ @try {
+ var octetstring vl_os := replace(vl_os0,3,2,'0011'O);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+//too long index: 5+0
+testcase tc_predef_replace_octetstring_18_bad() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ @try {
+ var octetstring vl_os := replace(vl_os0,5,0,'0011'O);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//too long index: 5+0, runtime
+testcase tc_predef_replace_octetstring_19_bad() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ var octetstring vl_os1 := '0011'O;
+ var integer idx := 5;
+ var integer len := 0;
+ @try {
+ var octetstring vl_os := replace(vl_os0,idx,len,vl_os1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//too long index: 3+2, runtime
+testcase tc_predef_replace_octetstring_20_bad() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ var octetstring vl_os1 := '0011'O;
+ var integer idx := 3;
+ var integer len := 2;
+ @try {
+ var octetstring vl_os := replace(vl_os0,idx,len,vl_os1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//negative index
+testcase tc_predef_replace_octetstring_21_bad() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ var octetstring vl_os1 := '0011'O;
+ var integer idx := -1;
+ var integer len := 2;
+ @try {
+ var octetstring vl_os := replace(vl_os0,idx,len,vl_os1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//negative length
+testcase tc_predef_replace_octetstring_22_bad() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ var octetstring vl_os1 := '0011'O;
+ var integer idx := 3;
+ var integer len := -2;
+ @try {
+ var octetstring vl_os := replace(vl_os0,idx,len,vl_os1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//uninit orig str
+testcase tc_predef_replace_octetstring_23_bad() runs on CT {
+ var octetstring vl_os0;
+ var octetstring vl_os1 := '0011'O;
+ var integer idx := 3;
+ var integer len := 2;
+ @try {
+ var octetstring vl_os := replace(vl_os0,idx,len,vl_os1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//uninit string to be inserted
+testcase tc_predef_replace_octetstring_24_bad() runs on CT {
+ var octetstring vl_os0 := '0000 1111'O
+ var octetstring vl_os1;
+ var integer idx := 3;
+ var integer len := 2;
+ @try {
+ var octetstring vl_os := replace(vl_os0,idx,len,vl_os1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+// var templates, append 2 chars runtime
+testcase tc_predef_replace_octetstring_25() runs on CT {
+ var template octetstring vl_os0 := '0000 1111'O
+ var template octetstring vl_os1 := '0011'O;
+ var integer idx := 4;
+ var integer len := 0;
+ var octetstring vl_os := replace(vl_os0, idx, len, vl_os1);
+
+ if(vl_os != '0000 1111 0011'O){
+ setverdict(fail, "expected '000011110011'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// templates, append 2 chars runtime
+testcase tc_predef_replace_octetstring_26() runs on CT {
+ template octetstring vl_os0 := '0000 1111'O
+ template octetstring vl_os1 := '0011'O;
+ var integer idx := 4;
+ var integer len := 0;
+ var octetstring vl_os := replace(vl_os0, idx, len, vl_os1);
+
+ if(vl_os != '0000 1111 0011'O){
+ setverdict(fail, "expected '000011110011'O got:", vl_os);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//*********** Replace() for charstring ***********
+
+// remove 2 chars from the beginnining, compile time
+testcase tc_predef_replace_charstring_1() runs on CT {
+ var charstring vl_bs := replace("0000 1111",0,2,"");
+ if(vl_bs != "00 1111"){
+ setverdict(fail, "expected \"001111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+//var pars
+testcase tc_predef_replace_charstring_1a() runs on CT {
+ var integer vl_beginning :=0, vl_len := 2;
+ var charstring vl_bs := replace("0000 1111",vl_beginning,vl_len,"");
+ if(vl_bs != "00 1111"){
+ setverdict(fail, "expected \"001111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+//const pars
+testcase tc_predef_replace_charstring_1b() runs on CT {
+ const integer vl_beginning :=0, vl_len := 2;
+ var charstring vl_bs := replace("0000 1111",vl_beginning,vl_len,"");
+ if(vl_bs != "00 1111"){
+ setverdict(fail, "expected \"001111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+// remove 2 chars from the beginnining, run time
+testcase tc_predef_replace_charstring_2() runs on CT {
+ var charstring vl_bs0 := "0000 1111"
+ var charstring vl_bs := replace(vl_bs0,0,2,"");
+ if(vl_bs != "00 1111"){
+ setverdict(fail, "expected \"001111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining, run time
+//parameters are variables
+testcase tc_predef_replace_charstring_2a() runs on CT {
+ var integer vl_beginning :=0, vl_len := 2;
+ var charstring vl_bs0 := "0000 1111"
+ var charstring vl_bs := replace(vl_bs0,vl_beginning,vl_len,"");
+ if(vl_bs != "00 1111"){
+ setverdict(fail, "expected \"001111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+// remove 2 chars from the beginnining,insert 1 char compile time
+testcase tc_predef_replace_charstring_3() runs on CT {
+ var charstring vl_bs := replace("0000 1111",0,2,"1");
+ if(vl_bs != "100 1111"){
+ setverdict(fail, "expected \"1001111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 1 char runtime
+testcase tc_predef_replace_charstring_4() runs on CT {
+ var charstring vl_bs0 := "0000 1111"
+ var charstring vl_bs := replace(vl_bs0,0,2,"1");
+ if(vl_bs != "100 1111"){
+ setverdict(fail, "expected \"1001111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining,insert 2 char compile time
+testcase tc_predef_replace_charstring_5() runs on CT {
+ var charstring vl_bs := replace("0000 1111",0,2,"11");
+ if(vl_bs != "1100 1111"){
+ setverdict(fail, "expected \"11001111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 2 char runtime
+testcase tc_predef_replace_charstring_6() runs on CT {
+ var charstring vl_bs0 := "0000 1111"
+ var charstring vl_bs := replace(vl_bs0,0,2,"11");
+ if(vl_bs != "1100 1111"){
+ setverdict(fail, "expected \"11001111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining,insert 3 char compile time
+testcase tc_predef_replace_charstring_7() runs on CT {
+ var charstring vl_bs := replace("0000 1111",0,2,"111");
+ if(vl_bs != "11100 1111"){
+ setverdict(fail, "expected \"11100 1111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 3 char runtime
+testcase tc_predef_replace_charstring_8() runs on CT {
+ var charstring vl_bs0 := "00001111"
+ var charstring vl_bs := replace(vl_bs0,0,2,"111");
+ if(vl_bs != "111001111"){
+ setverdict(fail, "expected \"111001111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the second char (index position 1), insert 3 char compile time
+testcase tc_predef_replace_charstring_9() runs on CT {
+ var charstring vl_bs := replace("00001111",1,2,"111");
+ if(vl_bs != "011101111"){
+ setverdict(fail, "expected \"011101111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the second char (index position 1), insert 3 char runtime
+testcase tc_predef_replace_charstring_10() runs on CT {
+ var charstring vl_bs0 := "00001111"
+ var charstring vl_bs := replace(vl_bs0,1,2,"111");
+ if(vl_bs != "011101111"){
+ setverdict(fail, "expected \"011101111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// append 3 chars compile time
+testcase tc_predef_replace_charstring_11() runs on CT {
+ var charstring vl_bs := replace("00001111",8,0,"011");
+ if(vl_bs != "00001111011"){
+ setverdict(fail, "expected \"00001111011\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// append 3 char runtime
+testcase tc_predef_replace_charstring_12() runs on CT {
+ var charstring vl_bs0 := "00001111"
+ var charstring vl_bs := replace(vl_bs0,8,0,"011");
+ if(vl_bs != "00001111011"){
+ setverdict(fail, "expected \"00001111011\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//Expected on-the-fly semantic marker:
+//The sum of the second operand (8) and the third operand (1) of operation `replace" is greater than the length of the first operand (8)
+//testcase tc_predef_replace_charstring_13_bad() runs on CT {
+// var charstring vl_bs := replace("0000 1111",8,1,"011");
+
+//}
+
+//too long index: 8+1
+testcase tc_predef_replace_charstring_14_bad() runs on CT {
+ var charstring vl_bs0 := "00001111"
+ @try {
+ var charstring vl_bs := replace(vl_bs0,8,1,"011");
+ setverdict(fail,"DTE expected, got:", vl_bs)
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//Expected on-the-fly semantic marker:
+//The sum of the second operand (8) and the third operand (1) of operation `replace" is greater than the length of the first operand (8)
+//testcase tc_predef_replace_charstring_15_bad() runs on CT {
+// var charstring vl_bs := replace("0000 1111",7,2,"011");
+//}
+////Expected on-the-fly semantic marker:
+////The third operand of operation `replace" should not be negative
+//testcase tc_predef_replace_charstring_15a_bad() runs on CT {
+// var charstring vl_bs := replace("00001111",7,-2,"011");
+//}
+//testcase tc_predef_replace_charstring_15b_bad() runs on CT {
+// var charstring vl_bs := replace("00001111",7,-2,"11"H);
+//}
+
+//too long index: 7+2
+testcase tc_predef_replace_charstring_16_bad() runs on CT {
+ var charstring vl_bs0 := "00001111"
+ @try {
+ var charstring vl_bs := replace(vl_bs0,7,2,"011");
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//to big idx 9+0
+testcase tc_predef_replace_charstring_17_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")
+ }
+}
+
+// remove 2 chars from the beginnining,insert 3 char runtime
+testcase tc_predef_replace_charstring_18() runs on CT {
+ var charstring vl_bs0 := "00001111"
+ var charstring vl_bs1 := "111";
+ var integer idx := 0;
+ var integer len := 2;
+ var charstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ if(vl_bs != "111001111"){
+ setverdict(fail, "expected \"111001111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+//too long index: 9+0, runtime
+testcase tc_predef_replace_charstring_19_bad() runs on CT {
+ var charstring vl_bs0 := "00001111";
+ var charstring vl_bs1 := "011";
+ var integer idx := 9;
+ var integer len := 0;
+ @try {
+ var charstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//too long index: 7+2, runtime
+testcase tc_predef_replace_charstring_20_bad() runs on CT {
+ var charstring vl_bs0 := "00001111";
+ var charstring vl_bs1 := "011";
+ var integer idx := 7;
+ var integer len := 2;
+ @try {
+ var charstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//neg index, runtime
+testcase tc_predef_replace_charstring_21_bad() runs on CT {
+ var charstring vl_bs0 := "00001111";
+ var charstring vl_bs1 := "011";
+ var integer idx := -1;
+ var integer len := 0;
+ @try {
+ var charstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//neg length, runtime
+testcase tc_predef_replace_charstring_22_bad() runs on CT {
+ var charstring vl_bs0 := "00001111";
+ var charstring vl_bs1 := "011";
+ var integer idx := 1;
+ var integer len := -2;
+ @try {
+ var charstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//uninit orig str, runtime
+testcase tc_predef_replace_charstring_23_bad() runs on CT {
+ var charstring vl_bs0 ;
+ var charstring vl_bs1 := "011";
+ var integer idx := 1;
+ var integer len := 2;
+ @try {
+ var charstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//uninit string to be inserted
+testcase tc_predef_replace_charstring_24_bad() runs on CT {
+ var charstring vl_bs0 := "00001111";
+ var charstring vl_bs1;
+ var integer idx := 1;
+ var integer len := 2;
+ @try {
+ var charstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+// var templates, remove 2 chars from the beginnining,insert 3 char runtime
+testcase tc_predef_replace_charstring_25() runs on CT {
+ var template charstring vl_bs0 := "00001111"
+ var template charstring vl_bs1 := "111";
+ var integer idx := 0;
+ var integer len := 2;
+ var charstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ if(vl_bs != "111001111"){
+ setverdict(fail, "expected \"111001111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//templates, remove 2 chars from the beginnining,insert 3 char runtime
+testcase tc_predef_replace_charstring_26() runs on CT {
+ template charstring vl_bs0 := "00001111"
+ template charstring vl_bs1 := "111";
+ var integer idx := 0;
+ var integer len := 2;
+ var charstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ if(vl_bs != "111001111"){
+ setverdict(fail, "expected \"111001111\" got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//uninit orig str, runtime
+testcase tc_predef_replace_charstring_27_bad() runs on CT {
+ var template charstring vl_bs0 ;
+ var template charstring vl_bs1 := "011";
+ var integer idx := 1;
+ var integer len := 2;
+ @try {
+ var charstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//uninit string to be inserted
+testcase tc_predef_replace_charstring_28_bad() runs on CT {
+ var template charstring vl_bs0 := "00001111";
+ var template charstring vl_bs1;
+ var integer idx := 1;
+ var integer len := 2;
+ @try {
+ var charstring vl_bs := replace(vl_bs0,idx,len,vl_bs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//======uchar CONT HERE
+
+//*********** Replace() for universal charstring ***********
+
+// remove 2 chars from the beginnining, compile time
+testcase tc_predef_replace_ucharstring_1() runs on CT {
+ var universal charstring vl_ucs := replace("0000 1111",0,2,"");
+ if(vl_ucs != "00 1111"){
+ setverdict(fail, "expected \"00 1111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+//var pars
+testcase tc_predef_replace_ucharstring_1a() runs on CT {
+ var integer vl_beginning :=0, vl_len := 2;
+ var universal charstring vl_ucs := replace("0000 1111",vl_beginning,vl_len,"");
+ if(vl_ucs != "00 1111"){
+ setverdict(fail, "expected \"001111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+//const pars
+testcase tc_predef_replace_ucharstring_1b() runs on CT {
+ const integer vl_beginning :=0, vl_len := 2;
+ var universal charstring vl_ucs := replace("0000 1111",vl_beginning,vl_len,"");
+ if(vl_ucs != "00 1111"){
+ setverdict(fail, "expected \"00 1111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+// remove 2 chars from the beginnining, run time
+testcase tc_predef_replace_ucharstring_2() runs on CT {
+ var universal charstring ucsa := char( 0,0,1, 123) & char( 0,0,2, 124)
+ var universal charstring ucsb := char( 0,0,1, 123) & char( 0,0,2, 124)
+ var universal charstring vl_ucs0 := ucsa & ucsb;
+ var universal charstring vl_ucs1 := "";
+ var universal charstring vl_ucs := replace(vl_ucs0, 0, 2, vl_ucs1);
+ if(vl_ucs != ucsa) {
+ setverdict(fail, "expected ",ucsa," got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//remove 2 chars from the beginnining, run time
+//parameters are variables
+testcase tc_predef_replace_ucharstring_2a() runs on CT {
+ var integer vl_beginning :=0, vl_len := 2;
+ var universal charstring vl_ucs0 := char(0,0,0,213) & "1234567890AZaz~"
+ var universal charstring vl_ucs1 := "";
+ var universal charstring vl_ucs := replace(vl_ucs0,vl_beginning,vl_len,vl_ucs1);
+ if(vl_ucs != "234567890AZaz~"){
+ setverdict(fail, "expected \"00 1111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+// remove 2 chars from the beginnining,insert 1 char compile time
+testcase tc_predef_replace_ucharstring_3() runs on CT {
+ var universal charstring vl_ucs := replace("0000 1111",0,2,"1");
+ if(vl_ucs != "100 1111"){
+ setverdict(fail, "expected \"1001111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 1 char runtime
+testcase tc_predef_replace_ucharstring_4() runs on CT {
+ var universal charstring vl_ucs0 := "0000 1111"
+ var integer idx :=0, len := 2;
+ var universal charstring vl_ucs1 := "1";
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len, vl_ucs1);
+ if(vl_ucs != "100 1111"){
+ setverdict(fail, "expected \"100 1111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining,insert 2 char compile time
+testcase tc_predef_replace_ucharstring_5() runs on CT {
+ var universal charstring vl_ucs := replace("0000 1111",0,2,"11");
+ if(vl_ucs != "1100 1111"){
+ setverdict(fail, "expected \"1100 1111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 2 char runtime
+testcase tc_predef_replace_ucharstring_6() runs on CT {
+ var universal charstring vl_ucs0 := "0000 1111";
+ var universal charstring vl_ucs1 := "11";
+ var universal charstring vl_ucs := replace(vl_ucs0,0,2,vl_ucs1);
+ if(vl_ucs != "1100 1111"){
+ setverdict(fail, "expected \"1100 1111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining,insert 3 char compile time
+testcase tc_predef_replace_ucharstring_7() runs on CT {
+ var universal charstring vl_ucs := replace("0000 1111",0,2,"111");
+ if(vl_ucs != "11100 1111"){
+ setverdict(fail, "expected \"11100 1111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 3 char runtime
+testcase tc_predef_replace_ucharstring_8() runs on CT {
+ var universal charstring vl_ucs0 := "00001111";
+ var universal charstring vl_ucs1 := "111"
+ var universal charstring vl_ucs := replace(vl_ucs0,0,2, vl_ucs1);
+ if(vl_ucs != "111001111"){
+ setverdict(fail, "expected \"111001111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the second char (index position 1), insert 3 char compile time
+testcase tc_predef_replace_ucharstring_9() runs on CT {
+ var universal charstring vl_ucs := replace("00001111",1,2,"111");
+ if(vl_ucs != "011101111"){
+ setverdict(fail, "expected \"011101111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the second char (index position 1), insert 3 char runtime
+testcase tc_predef_replace_ucharstring_10() runs on CT {
+ var universal charstring vl_ucs0 := "00001111"
+ var universal charstring vl_ucs1 := "111"
+ var universal charstring vl_ucs := replace(vl_ucs0,1,2,vl_ucs1);
+ if(vl_ucs != "011101111"){
+ setverdict(fail, "expected \"011101111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// append 3 chars compile time
+testcase tc_predef_replace_ucharstring_11() runs on CT {
+ var universal charstring vl_ucs := replace("00001111",8,0,"011");
+ if(vl_ucs != "00001111011"){
+ setverdict(fail, "expected \"00001111011\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// append 3 char runtime
+testcase tc_predef_replace_ucharstring_12() runs on CT {
+ var universal charstring vl_ucs0 := "00001111"
+ var universal charstring vl_ucs1 := "011"
+ var universal charstring vl_ucs := replace(vl_ucs0,8,0,vl_ucs1);
+ if(vl_ucs != "00001111011"){
+ setverdict(fail, "expected \"00001111011\" got:", vl_ucs);
+ } 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_ucharstring_13_bad() runs on CT {
+// var charstring vl_ucs := replace("0000 1111",8,1,"011");
+
+//}
+
+//too long index: 8+1
+testcase tc_predef_replace_ucharstring_14_bad() runs on CT {
+ var universal charstring vl_ucs0 := "00001111";
+ var universal charstring vl_ucs1 := "011"
+ @try {
+ var universal charstring vl_ucs := replace(vl_ucs0,8,1, vl_ucs1);
+ setverdict(fail,"DTE expected, got:", vl_ucs)
+ }
+ @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_ucharstring_15_bad() runs on CT {
+// var charstring vl_ucs := 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_ucharstring_15a_bad() runs on CT {
+// var charstring vl_ucs := replace("00001111",7,-2,"011");
+//}
+//testcase tc_predef_replace_ucharstring_15b_bad() runs on CT {
+// var charstring vl_ucs := replace("00001111",7,-2,"11"H);
+//}
+
+//too long index: 7+2
+testcase tc_predef_replace_ucharstring_16_bad() runs on CT {
+ var universal charstring vl_ucs0 := "00001111"
+ var universal charstring vl_ucs1 := "011"
+ @try {
+ var universal charstring vl_ucs := replace(vl_ucs0,7,2,vl_ucs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//to big idx 9+0
+testcase tc_predef_replace_ucharstring_17_bad() runs on CT {
+ var universal charstring vl_ucs0 := "00001111";
+ var universal charstring vl_ucs1 := "011"
+ @try {
+ var universal charstring vl_ucs := replace(vl_ucs0,9,0,vl_ucs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+// remove 2 chars from the beginnining,insert 3 char runtime
+testcase tc_predef_replace_ucharstring_18() runs on CT {
+ var universal charstring vl_ucs0 := "00001111"
+ var universal charstring vl_ucs1 := "111";
+ var integer idx := 0;
+ var integer len := 2;
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len,vl_ucs1);
+ if(vl_ucs != "111001111"){
+ setverdict(fail, "expected \"111001111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining,insert 3 char runtime
+//The repl is real univ charstr
+testcase tc_predef_replace_ucharstring_18a() runs on CT {
+ var universal charstring vl_ucs0 := "00001111";
+ var universal charstring vl_ucs1 := char(0,0,1,125) & "11";
+ var universal charstring exp := char(0,0,1,125) & "11001111"
+ var integer idx := 0;
+ var integer len := 2;
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len,vl_ucs1);
+ if(vl_ucs != exp){
+ setverdict(fail, "expected ", exp, "got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining,insert 3 char runtime
+//The first value is real univ charstr
+testcase tc_predef_replace_ucharstring_18b() runs on CT {
+ var universal charstring vl_ucs0 := char(0,1,2,127) & "0001111"
+ var universal charstring vl_ucs1 := "111";
+ var integer idx := 0;
+ var integer len := 2;
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len,vl_ucs1);
+ if(vl_ucs != "111001111"){
+ setverdict(fail, "expected \"111001111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//too long index: 9+0, runtime
+testcase tc_predef_replace_ucharstring_19_bad() runs on CT {
+ var universal charstring vl_ucs0 := "00001111";
+ var universal charstring vl_ucs1 := "011";
+ var integer idx := 9;
+ var integer len := 0;
+ @try {
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len,vl_ucs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//too long index: 7+2, runtime
+testcase tc_predef_replace_ucharstring_20_bad() runs on CT {
+ var universal charstring vl_ucs0 := "00001111";
+ var universal charstring vl_ucs1 := "011";
+ var integer idx := 7;
+ var integer len := 2;
+ @try {
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len,vl_ucs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//neg index, runtime
+testcase tc_predef_replace_ucharstring_21_bad() runs on CT {
+ var universal charstring vl_ucs0 := "00001111";
+ var universal charstring vl_ucs1 := "011";
+ var integer idx := -1;
+ var integer len := 0;
+ @try {
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len,vl_ucs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//neg length, runtime
+testcase tc_predef_replace_ucharstring_22_bad() runs on CT {
+ var universal charstring vl_ucs0 := "00001111";
+ var universal charstring vl_ucs1 := "011";
+ var integer idx := 1;
+ var integer len := -2;
+ @try {
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len,vl_ucs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//uninit orig str, runtime
+testcase tc_predef_replace_ucharstring_23_bad() runs on CT {
+ var universal charstring vl_ucs0 ;
+ var universal charstring vl_ucs1 := "011";
+ var integer idx := 1;
+ var integer len := 2;
+ @try {
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len,vl_ucs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//uninit string to be inserted
+testcase tc_predef_replace_ucharstring_24_bad() runs on CT {
+ var universal charstring vl_ucs0 := "00001111";
+ var universal charstring vl_ucs1;
+ var integer idx := 1;
+ var integer len := 2;
+ @try {
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len,vl_ucs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+// var templates, remove 2 chars from the beginnining,insert 3 char runtime
+testcase tc_predef_replace_ucharstring_25() runs on CT {
+ var template universal charstring vl_ucs0 := "00001111"
+ var template universal charstring vl_ucs1 := "111";
+ var integer idx := 0;
+ var integer len := 2;
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len,vl_ucs1);
+ if(vl_ucs != "111001111"){
+ setverdict(fail, "expected \"111001111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//templates, remove 2 chars from the beginnining,insert 3 char runtime
+testcase tc_predef_replace_ucharstring_26() runs on CT {
+ template universal charstring vl_ucs0 := "00001111"
+ template universal charstring vl_ucs1 := "111";
+ var integer idx := 0;
+ var integer len := 2;
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len,vl_ucs1);
+ if(vl_ucs != "111001111"){
+ setverdict(fail, "expected \"111001111\" got:", vl_ucs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//uninit orig str, runtime
+testcase tc_predef_replace_ucharstring_27_bad() runs on CT {
+ var template universal charstring vl_ucs0 ;
+ var template universal charstring vl_ucs1 := "011";
+ var integer idx := 1;
+ var integer len := 2;
+ @try {
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len,vl_ucs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//uninit string to be inserted
+testcase tc_predef_replace_ucharstring_28_bad() runs on CT {
+ var template universal charstring vl_ucs0 := "00001111";
+ var template universal charstring vl_ucs1;
+ var integer idx := 1;
+ var integer len := 2;
+ @try {
+ var universal charstring vl_ucs := replace(vl_ucs0,idx,len,vl_ucs1);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//********** Replace for RoI *******************
+// remove 2 chars from the beginnining, compile time
+testcase tc_predef_replace_RoI_1() runs on CT {
+ const RoI vl_roi := {0,1,2,3,4,5,6,7};
+ const RoI vl_bs := replace(vl_roi,0,2,c_roi_empty);
+ if(vl_bs != {2,3,4,5,6,7}){
+ setverdict(fail, "expected {2,3,4,5,6,7} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+//var pars
+testcase tc_predef_replace_RoI_1a() runs on CT {
+ const RoI vl_roi := {0,1,2,3,4,5,6,7};
+ const integer vl_beginning :=0, vl_len := 2;
+ var RoI vl_bs := replace(vl_roi,vl_beginning,vl_len,c_roi_empty);
+ if(vl_bs != {2,3,4,5,6,7}){
+ setverdict(fail, "expected {2,3,4,5,6,7,} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+//const pars
+testcase tc_predef_replace_RoI_1b() runs on CT {
+ var RoI vl_roi := {0,1,2,3,4,5,6,7};
+ var integer vl_beginning := 0, vl_len := 2;
+ var RoI vl_bs := replace(vl_roi,vl_beginning,vl_len,c_roi_empty);
+ if(vl_bs != {2,3,4,5,6,7}){
+ setverdict(fail, "expected {2,3,4,5,6,7} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+// remove 2 chars from the beginnining, run time
+testcase tc_predef_replace_RoI_2() runs on CT {
+ var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ var RoI vl_bs := replace(vl_bs0,0,2,c_roi_empty);
+ if(vl_bs != {2,3,4,5,6,7}){
+ setverdict(fail, "expected {2,3,4,5,6,7} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 elements from the beginnining, run time
+//parameters are variables
+testcase tc_predef_replace_RoI_2a() runs on CT {
+ var integer vl_beginning :=0, vl_len := 2;
+ var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ var RoI vl_bs := replace(vl_bs0,vl_beginning,vl_len,c_roi_empty);
+ if(vl_bs != {2,3,4,5,6,7}){
+ setverdict(fail, "expected {2,3,4,5,6,7} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+// remove 2 chars from the beginnining,insert 1 char compile time
+testcase tc_predef_replace_RoI_3() runs on CT {
+ const RoI vl_roi := {0,1,2,3,4,5,6,7};
+ const RoI vl_bs := replace(vl_roi,0,2,c_roi_1);
+ if(vl_bs != {-1,2,3,4,5,6,7}){
+ setverdict(fail, "expected {-1,2,3,4,5,6,7} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 1 char runtime
+testcase tc_predef_replace_RoI_4() runs on CT {
+ var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ var RoI vl_bs := replace(vl_bs0,0,2,c_roi_1);
+ if(vl_bs != {-1,2,3,4,5,6,7}){
+ setverdict(fail, "expected {-1,2,3,4,5,6,7} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining,insert 2 char compile time
+testcase tc_predef_replace_RoI_5() runs on CT {
+ const RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ const RoI vl_bs := replace(vl_bs0,0,2,c_roi_2);
+ if(vl_bs != {-2,-1,2,3,4,5,6,7}){
+ setverdict(fail, "expected {-2,-1,2,3,4,5,6,7} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 2 char runtime
+testcase tc_predef_replace_RoI_6() runs on CT {
+ var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ var RoI vl_bs := replace(vl_bs0,0,2, c_roi_2);
+ if(vl_bs != {-2,-1,2,3,4,5,6,7}){
+ setverdict(fail, "expected {-2,-1,2,3,4,5,6,7} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the beginnining,insert 3 char compile time
+testcase tc_predef_replace_RoI_7() runs on CT {
+ const RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ const RoI vl_bs := replace(vl_bs0,0,2, c_roi_2 & {-3} );
+ if(vl_bs != {-2,-1,-3,2,3,4,5,6,7}){
+ setverdict(fail, "expected {-2,-1,-3,2,3,4,5,6,7} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the beginnining,insert 3 char runtime
+testcase tc_predef_replace_RoI_8() runs on CT {
+ var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ const RoI vl_roi3 := {-3,-2,-1}
+ var RoI vl_bs := replace(vl_bs0,0,2,vl_roi3);
+ if(vl_bs != {-3,-2,-1,2,3,4,5,6,7}){
+ setverdict(fail, "expected {-3,-2,-1,2,3,4,5,6,7} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// remove 2 chars from the second char (index position 1), insert 3 char compile time
+testcase tc_predef_replace_RoI_9() runs on CT {
+ var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ var RoI vl_bs := replace(vl_bs0,1,2,c_roi3);
+ if(vl_bs != {0,-3,-2,-1,3,4,5,6,7}){
+ setverdict(fail, "expected {0,-3,-2,-1,3,4,5,6,7} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// remove 2 chars from the second char (index position 1), insert 3 char runtime
+testcase tc_predef_replace_RoI_10() runs on CT {
+ var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ const RoI vl_roi3 := {-3,-2,-1}
+ var RoI vl_bs := replace(vl_bs0,1,2,vl_roi3);
+ if(vl_bs != {0,-3,-2,-1,3,4,5,6,7}){
+ setverdict(fail, "expected {0,-3,-2,-1,3,4,5,6,7} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+// append 3 chars compile time
+testcase tc_predef_replace_RoI_11() runs on CT {
+ const RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ const RoI vl_bs := replace(vl_bs0,8,0,c_roi3);
+ if(vl_bs != {0,1,2,3,4,5,6,7,-3,-2,-1}){
+ setverdict(fail, "expected {0,1,2,3,4,5,6,7,-3,-2,-1} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+
+}
+// append 3 char runtime
+testcase tc_predef_replace_RoI_12() runs on CT {
+ var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ var RoI vl_bs := replace(vl_bs0,8,0,c_roi3);
+ if(vl_bs != {0,1,2,3,4,5,6,7,-3,-2,-1}){
+ setverdict(fail, "expected {0,1,2,3,4,5,6,7,-3,-2,-1} got:", vl_bs);
+ } else {
+ setverdict(pass);
+ }
+}
+
+//Expected on-the-fly semantic marker:
+//The sum of the second operand (8) and the third operand (1) of operation `replace" is greater than the length of the first operand (8)
+//testcase tc_predef_replace_RoI_13_bad() runs on CT {
+// const RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+// @try {
+// var RoI vl_bs := replace(vl_bs0,8,1,c_roi3);
+// setverdict(fail,"DTE expected, got:", vl_bs)
+// }
+// @catch(e) {
+// setverdict(pass,"Expected DTE catched")
+// }
+//}
+
+//too long index: 8+1, runtime recognition
+testcase tc_predef_replace_RoI_14_bad() runs on CT {
+ var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ var integer vl_len := 1;
+ @try {
+ var RoI vl_bs := replace(vl_bs0,8,1,c_roi3);
+ setverdict(fail,"DTE expected, got:", vl_bs)
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//Expected on-the-fly semantic marker:
+//The sum of the second operand (8) and the third operand (1) of operation `replace" is greater than the length of the first operand (8)
+//testcase tc_predef_replace_RoI_15_bad() runs on CT {
+// var RoI vl_bs := replace({0,1,2,3,4,5,6,7},7,2,"011");
+//}
+////Expected on-the-fly semantic marker:
+////The third operand of operation `replace" should not be negative
+//testcase tc_predef_replace_RoI_15a_bad() runs on CT {
+// var RoI vl_bs := replace("00001111",7,-2,"011");
+//}
+//testcase tc_predef_replace_RoI_15b_bad() runs on CT {
+// var RoI vl_bs := replace("00001111",7,-2,"11"H);
+//}
+
+//too long index: 7+2
+testcase tc_predef_replace_RoI_16_bad() runs on CT {
+ var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ @try {
+ var RoI vl_bs := replace(vl_bs0,7,2,c_roi3);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+//too long index: 9+0
+testcase tc_predef_replace_RoI_18_bad() runs on CT {
+ var RoI vl_bs0 := {0,1,2,3,4,5,6,7}
+ @try {
+ var RoI vl_bs := replace(vl_bs0,9,0,c_roi3);
+ setverdict(fail,"DTE expected")
+ }
+ @catch(e) {
+ setverdict(pass,"Expected DTE catched")
+ }
+}
+
+//======== str2bit ==========
+testcase tc_predef_str2bit_good1() runs on CT {
+ var RoCS vl_roc := {"","01","00001111","11110000111100001","1111000011110000111110000111100001"}
+ var RoBS vl_expected := {''B,'01'B,'0000 1111'B,'11110000111100001'B,'1111000011110000111110000111100001'B}
+ var integer N := sizeof( vl_roc );
+
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(str2bit(vl_roc[i])!=vl_expected[i]) {
+ setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",str2bit(vl_roc[i]));
+ }
+ }
+ setverdict(pass);
+}
+//compile time cases
+testcase tc_predef_str2bit_good2() runs on CT {
+ const charstring vl_cs := "11110000111100001";
+ const bitstring vl_bs := '11110000111100001'B;
+ if(str2bit(vl_cs)!= vl_bs){
+ setverdict(fail,"expected:", vl_bs," got: ", str2bit(vl_cs));
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_str2bit_good2a() runs on CT {
+ const charstring vl_cs := "";
+ const bitstring vl_bs := ''B;
+ if(str2bit(vl_cs)!= vl_bs){
+ setverdict(fail,"expected: ''B got: ", str2bit(vl_cs));
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_str2bit_good3() runs on CT {
+ const charstring vl_cs := "11110000111100001";
+ const bitstring vl_bs := '11110000111100001'B;
+ var integer N := lengthof(vl_cs);
+ for( var integer i:=0;i<N;i:=i+1) {
+ if(str2bit(vl_cs[i])!= vl_bs[i]){
+ setverdict(fail,i,": expected:", vl_bs[i]," got: ", str2bit(vl_cs[i]));
+ }
+ }
+ setverdict(pass);
+}
+//str2float -- see at the beginning!
+
+//str2hex
+testcase tc_predef_str2hex_good1() runs on CT {
+ var RoCS vl_roc := {"","01","00001111","11110000111100001","1111000011110000111110000111100001"}
+ var RoHS vl_expected := {''H,'01'H,'0000 1111'H,'11110000111100001'H,'1111000011110000111110000111100001'H}
+ var integer N := sizeof( vl_roc );
+
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(str2hex(vl_roc[i])!=vl_expected[i]) {
+ setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",str2hex(vl_roc[i]));
+ }
+ }
+ setverdict(pass);
+}
+//compile time cases
+testcase tc_predef_str2hex_good2() runs on CT {
+ const charstring vl_cs := "11110000111100001";
+ const hexstring vl_bs := '11110000111100001'H;
+ if(str2hex(vl_cs)!= vl_bs){
+ setverdict(fail,"expected:", vl_bs," got: ", str2hex(vl_cs));
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_str2hex_good2a() runs on CT {
+ const charstring vl_cs := "";
+ const hexstring vl_bs := ''H;
+ if(str2hex(vl_cs)!= vl_bs){
+ setverdict(fail,"expected: ''H got: ", str2hex(vl_cs));
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_str2hex_good3() runs on CT {
+ const charstring vl_cs := "11110000111100001";
+ const hexstring vl_bs := '11110000111100001'H;
+ var integer N := lengthof(vl_cs);
+ for( var integer i:=0;i<N;i:=i+1) {
+ if(str2hex(vl_cs[i])!= vl_bs[i]){
+ setverdict(fail,i,": expected:", vl_bs[i]," got: ", str2hex(vl_cs[i]));
+ }
+ }
+ setverdict(pass);
+}
+//str2int
+testcase tc_predef_str2int_good1() runs on CT {
+ var RoCS vl_roc := {"01","00001111","111100001111000010","1111000011110000111110000111100001"}
+ var RoI vl_expected := { 1, 1111,111100001111000010,1111000011110000111110000111100001}
+ var integer N := sizeof( vl_roc );
+
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(str2int(vl_roc[i])!=vl_expected[i]) {
+ setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",str2int(vl_roc[i]));
+ }
+ }
+ setverdict(pass);
+}
+//compile time cases
+testcase tc_predef_str2int_good2() runs on CT {
+ const charstring vl_cs := "111100001111000010";
+ const integer vl_bs := 111100001111000010;
+ if(str2int(vl_cs)!= vl_bs){
+ setverdict(fail,"expected:", vl_bs," got: ", str2int(vl_cs));
+ }
+ setverdict(pass);
+}
+// semantic error, as it is required!
+//testcase tc_predef_str2int_good2a() runs on CT {
+// const charstring vl_cs := "";
+// @try {
+// const integer vl_bs := str2int(vl_cs);
+// setverdict(fail,"expected: ''O got: ", str2oct(vl_cs));
+// }
+// @catch(e){
+// setverdict(pass);
+// }
+//}
+
+//str2oct
+testcase tc_predef_str2oct_good1() runs on CT {
+ var RoCS vl_roc := {"","01","00001111","111100001111000010","1111000011110000111110000111100001"}
+ var RoOS vl_expected := {''O,'01'O,'0000 1111'O,'111100001111000010'O,'1111000011110000111110000111100001'O}
+ var integer N := sizeof( vl_roc );
+
+ for(var integer i:=0;i<N; i:=i+1) {
+ if(str2oct(vl_roc[i])!=vl_expected[i]) {
+ setverdict(fail,"Expected(",i,"): ", vl_expected[i], "got:",str2oct(vl_roc[i]));
+ }
+ }
+ setverdict(pass);
+}
+//compile time cases
+testcase tc_predef_str2oct_good2() runs on CT {
+ const charstring vl_cs := "111100001111000010";
+ const octetstring vl_bs := '111100001111000010'O;
+ if(str2oct(vl_cs)!= vl_bs){
+ setverdict(fail,"expected:", vl_bs," got: ", str2oct(vl_cs));
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_str2oct_good2a() runs on CT {
+ const charstring vl_cs := "";
+ const octetstring vl_bs := ''O;
+ if(str2oct(vl_cs)!= vl_bs){
+ setverdict(fail,"expected: ''O got: ", str2oct(vl_cs));
+ }
+ setverdict(pass);
+}
+//=============================================
+//============ substring ======================
+//=============================================
+
+//--- bitstring ---
+//compile time
+testcase tc_predef_substring_bitstring1() runs on CT {
+ const bitstring vl_cs := ''B;
+ const bitstring vl_bs := substr(vl_cs, 0,0)
+ if(vl_bs!=''B){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_bitstring2() runs on CT {
+ var bitstring vl_cs := ''B;
+ var bitstring vl_bs := substr(vl_cs, 0,0);
+ log(vl_bs);
+ if( vl_bs!=''B){
+ setverdict(fail);
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_bitstring3() runs on CT {
+ // const bitstring vl_cs := ''B;
+ const bitstring vl_bs := substr('00100110'B, 3, 4)
+ if(vl_bs!='0011'B){
+ setverdict(fail);
+ }
+
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_bitstring4() runs on CT {
+ var bitstring vl_cs := '00100110'B;
+ var bitstring vl_bs := substr(vl_cs, 3,4)
+ if(vl_bs!='0011'B){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_bitstring5() runs on CT {
+ const bitstring vl_cs := '00100110'B;
+ const bitstring vl_bs := substr(vl_cs, 3, 5)
+ if(vl_bs!='00110'B){
+ setverdict(fail);
+ }
+
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_bitstring6() runs on CT {
+ var bitstring vl_cs := '00100110'B;
+ var bitstring vl_bs := substr(vl_cs, 3,5)
+ if(vl_bs!='00110'B){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+//semantic error (before compile time)
+//testcase tc_predef_substring_bitstring7() runs on CT {
+// const bitstring vl_cs := '00100110'B;
+// const bitstring vl_bs := substr(vl_cs, 3, 6)
+// setverdict(fail);
+//}
+//runtime error
+testcase tc_predef_substring_bitstring8() runs on CT {
+ var bitstring vl_cs := '00100110'B;
+ @try {
+ var bitstring vl_bs := substr(vl_cs, 3,6)
+ setverdict(fail,"DTE expected");
+ }
+ @catch(e){
+ setverdict(pass);
+ }
+}
+
+//semantic error (before compile time)
+//testcase tc_predef_substring_bitstring9() runs on CT {
+// const bitstring vl_cs := '00100110'B;
+// const bitstring vl_bs := substr(vl_cs, 9, 0)
+// setverdict(fail);
+//}
+//runtime error
+testcase tc_predef_substring_bitstring10() runs on CT {
+ var bitstring vl_cs := '00100110'B;
+ @try {
+ var bitstring vl_bs := substr(vl_cs, 9,0)
+ setverdict(fail,"DTE expected");
+ }
+ @catch(e){
+ setverdict(pass);
+ }
+}
+
+//--- hexstring ---
+//compile time
+testcase tc_predef_substring_hexstring1() runs on CT {
+ const hexstring vl_cs := ''H;
+ const hexstring vl_bs := substr(vl_cs, 0,0)
+ if(vl_bs!=''H){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_hexstring2() runs on CT {
+ var hexstring vl_cs := ''H;
+ var hexstring vl_bs := substr(vl_cs, 0,0);
+ log(vl_bs);
+ if( vl_bs!=''H){
+ setverdict(fail);
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_hexstring3() runs on CT {
+ // const hexstring vl_cs := ''H;
+ const hexstring vl_bs := substr('00100110'H, 3, 4)
+ if(vl_bs!='0011'H){
+ setverdict(fail);
+ }
+
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_hexstring4() runs on CT {
+ var hexstring vl_cs := '00100110'H;
+ var hexstring vl_bs := substr(vl_cs, 3,4)
+ if(vl_bs!='0011'H){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_hexstring5() runs on CT {
+ const hexstring vl_cs := '00100110'H;
+ const hexstring vl_bs := substr(vl_cs, 3, 5)
+ if(vl_bs!='00110'H){
+ setverdict(fail);
+ }
+
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_hexstring6() runs on CT {
+ var hexstring vl_cs := '00100110'H;
+ var hexstring vl_bs := substr(vl_cs, 3,5)
+ if(vl_bs!='00110'H){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+//semantic error (before compile time)
+//testcase tc_predef_substring_hexstring7() runs on CT {
+// const hexstring vl_cs := '00100110'H;
+// const hexstring vl_bs := substr(vl_cs, 3, 6)
+// setverdict(fail);
+//}
+//runtime error
+testcase tc_predef_substring_hexstring8() runs on CT {
+ var hexstring vl_cs := '00100110'H;
+ @try {
+ var hexstring vl_bs := substr(vl_cs, 3,6)
+ setverdict(fail,"DTE expected");
+ }
+ @catch(e){
+ setverdict(pass);
+ }
+}
+
+//semantic error (before compile time)
+//testcase tc_predef_substring_hexstring9() runs on CT {
+// const hexstring vl_cs := '00100110'H;
+// const hexstring vl_bs := substr(vl_cs, 9, 0)
+// setverdict(fail);
+//}
+//runtime error
+testcase tc_predef_substring_hexstring10() runs on CT {
+ var hexstring vl_cs := '00100110'H;
+ @try {
+ var hexstring vl_bs := substr(vl_cs, 9,0)
+ setverdict(fail,"DTE expected");
+ }
+ @catch(e){
+ setverdict(pass);
+ }
+}
+//--- octetstring ---
+//compile time
+testcase tc_predef_substring_octetstring1() runs on CT {
+ const octetstring vl_cs := ''O;
+ const octetstring vl_bs := substr(vl_cs, 0,0)
+ if(vl_bs!=''O){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_octetstring2() runs on CT {
+ var octetstring vl_cs := ''O;
+ var octetstring vl_bs := substr(vl_cs, 0,0);
+ log(vl_bs);
+ if( vl_bs!=''O){
+ setverdict(fail);
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_octetstring3() runs on CT {
+ // const octetstring vl_cs := ''O;
+ const octetstring vl_bs := substr('00100110'O, 1, 2)
+ if(vl_bs!='1001'O){
+ setverdict(fail);
+ }
+
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_octetstring4() runs on CT {
+ var octetstring vl_cs := '00100110'O;
+ var octetstring vl_bs := substr(vl_cs, 1,2)
+ if(vl_bs!='1001'O){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_octetstring5() runs on CT {
+ const octetstring vl_cs := '00100110'O;
+ const octetstring vl_bs := substr(vl_cs, 1,3)
+ if(vl_bs!='100110'O){
+ setverdict(fail);
+ }
+
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_octetstring6() runs on CT {
+ var octetstring vl_cs := '00100110'O;
+ var octetstring vl_bs := substr(vl_cs, 1,3)
+ if(vl_bs!='100110'O){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+//semantic error (before compile time)
+//testcase tc_predef_substring_octetstring7() runs on CT {
+// const octetstring vl_cs := '00100110'O;
+// const octetstring vl_bs := substr(vl_cs,1,4)
+// setverdict(fail);
+//}
+
+//runtime error
+testcase tc_predef_substring_octetstring8() runs on CT {
+ var octetstring vl_cs := '01020304'O;
+ @try {
+ var octetstring vl_bs := substr(vl_cs,1,4)
+ setverdict(fail,"DTE expected");
+ }
+ @catch(e){
+ setverdict(pass);
+ }
+}
+
+//semantic error (before compile time)
+//testcase tc_predef_substring_octetstring9() runs on CT {
+// const octetstring vl_cs := '00100110'O;
+// const octetstring vl_bs := substr(vl_cs, 5, 0)
+// setverdict(fail);
+//}
+//runtime error
+testcase tc_predef_substring_octetstring10() runs on CT {
+ var octetstring vl_cs := '00100110'O;
+ @try {
+ var octetstring vl_bs := substr(vl_cs, 5,0)
+ setverdict(fail,"DTE expected");
+ }
+ @catch(e){
+ setverdict(pass);
+ }
+}
+
+//---charstring---
+testcase tc_predef_substring_charstring1() runs on CT {
+ const charstring vl_cs := "";
+ const charstring vl_bs := substr(vl_cs, 0,0)
+ if(vl_bs!=""){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_charstring2() runs on CT {
+ var charstring vl_cs := "";
+ var charstring vl_bs := substr(vl_cs, 0,0);
+ log(vl_bs);
+ if( vl_bs!=""){
+ setverdict(fail);
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_charstring3() runs on CT {
+ // const charstring vl_cs := "";
+ const charstring vl_bs := substr("00100110", 3, 4)
+ if(vl_bs!="0011"){
+ setverdict(fail);
+ }
+
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_charstring4() runs on CT {
+ var charstring vl_cs := "00100110";
+ var charstring vl_bs := substr(vl_cs, 3,4)
+ if(vl_bs!="0011"){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_charstring5() runs on CT {
+ const charstring vl_cs := "00100110";
+ const charstring vl_bs := substr(vl_cs, 3, 5)
+ if(vl_bs!="00110"){
+ setverdict(fail);
+ }
+
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_charstring6() runs on CT {
+ var charstring vl_cs := "00100110";
+ var charstring vl_bs := substr(vl_cs, 3,5)
+ if(vl_bs!="00110"){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+//semantic error (before compile time)
+//testcase tc_predef_substring_charstring7() runs on CT {
+// const charstring vl_cs := "00100110";
+// const charstring vl_bs := substr(vl_cs, 3, 6)
+// setverdict(fail);
+//}
+//runtime error
+testcase tc_predef_substring_charstring8() runs on CT {
+ var charstring vl_cs := "00100110";
+ @try {
+ var charstring vl_bs := substr(vl_cs, 3,6)
+ setverdict(fail,"DTE expected");
+ }
+ @catch(e){
+ setverdict(pass);
+ }
+}
+
+//semantic error (before compile time)
+//testcase tc_predef_substring_charstring9() runs on CT {
+// const charstring vl_cs := "00100110";
+// const charstring vl_bs := substr(vl_cs, 9, 0)
+// setverdict(fail);
+//}
+//runtime error
+testcase tc_predef_substring_charstring10() runs on CT {
+ var charstring vl_cs := "00100110";
+ @try {
+ var charstring vl_bs := substr(vl_cs, 9,0)
+ setverdict(fail,"DTE expected");
+ }
+ @catch(e){
+ setverdict(pass);
+ }
+}
+//---RoI---
+// Semantic analyzer error
+//testcase tc_predef_substring_RoI1() runs on CT {
+// const RoI vl_cs := {};
+// const RoI vl_bs := substr(vl_cs, 0,0)
+// if(vl_bs!={}){
+// setverdict(fail);
+// }
+// log(vl_bs);
+// setverdict(pass);
+//}
+
+testcase tc_predef_substring_RoI2() runs on CT {
+ var RoI vl_cs := {};
+ var RoI vl_bs := substr(vl_cs, 0,0);
+ log(vl_bs);
+ if( vl_bs!={}){
+ setverdict(fail);
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_RoI3() runs on CT {
+ const RoI vl_cs := {0,1,2,3,4,5,6,7};
+ const RoI vl_bs := substr(vl_cs, 3, 4)
+ if(vl_bs!={3,4,5,6}){
+ setverdict(fail);
+ }
+
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_RoI4() runs on CT {
+ var RoI vl_cs := {0,1,2,3,4,5,6,7};
+ var RoI vl_bs := substr(vl_cs, 3,4)
+ if(vl_bs!={3,4,5,6}){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_RoI5() runs on CT {
+ const RoI vl_cs := {0,1,2,3,4,5,6,7};
+ const RoI vl_bs := substr(vl_cs, 3, 5)
+ if(vl_bs!={3,4,5,6,7}){
+ setverdict(fail);
+ }
+
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_RoI6() runs on CT {
+ var RoI vl_cs := {0,1,2,3,4,5,6,7};
+ var RoI vl_bs := substr(vl_cs, 3,5)
+ if(vl_bs!={3,4,5,6,7}){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_RoI6a() runs on CT {
+ const RoI vl_cs := {0,1,2,3,4,5,6,7};
+ const RoI vl_bs := substr(vl_cs, 8,0)
+ if(vl_bs!={}){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_RoI6b() runs on CT {
+ var RoI vl_cs := {0,1,2,3,4,5,6,7};
+ var RoI vl_bs := substr(vl_cs, 8,0)
+ if(vl_bs!={}){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+
+
+//semantic error (before compile time)
+//testcase tc_predef_substring_RoI7() runs on CT {
+// const RoI vl_cs := {0,1,2,3,4,5,6,7};
+// const RoI vl_bs := substr(vl_cs, 3, 6)
+// setverdict(fail);
+//}
+//runtime error
+testcase tc_predef_substring_RoI8() runs on CT {
+ var RoI vl_cs := {0,1,2,3,4,5,6,7};
+ @try {
+ var RoI vl_bs := substr(vl_cs, 3,6)
+ setverdict(fail,"DTE expected");
+ }
+ @catch(e){
+ setverdict(pass);
+ }
+}
+
+//semantic error (before compile time)
+//testcase tc_predef_substring_RoI9() runs on CT {
+// const RoI vl_cs := {0,1,2,3,4,5,6,7};
+// const RoI vl_bs := substr(vl_cs, 9, 0)
+// setverdict(fail);
+//}
+//runtime error
+testcase tc_predef_substring_RoI10() runs on CT {
+ var RoI vl_cs := {0,1,2,3,4,5,6,7};
+ @try {
+ var RoI vl_bs := substr(vl_cs, 9,0)
+ setverdict(fail,"DTE expected");
+ }
+ @catch(e){
+ setverdict(pass);
+ }
+}
+//----SoI---
+//---RoI---
+// Semantic analyzer error
+//testcase tc_predef_substring_SoI1() runs on CT {
+// const SoI vl_cs := {};
+// const SoI vl_bs := substr(vl_cs, 0,0)
+// if(vl_bs!={}){
+// setverdict(fail);
+// }
+// log(vl_bs);
+// setverdict(pass);
+//}
+
+testcase tc_predef_substring_SoI2() runs on CT {
+ var SoI vl_cs := {};
+ var SoI vl_bs := substr(vl_cs, 0,0);
+ log(vl_bs);
+ if( vl_bs!={}){
+ setverdict(fail);
+ }
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_SoI3() runs on CT {
+ const SoI vl_cs := {0,1,2,3,4,5,6,7};
+ const SoI vl_bs := substr(vl_cs, 3, 4)
+ if(vl_bs!={3,4,5,6}){
+ setverdict(fail);
+ }
+
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_SoI4() runs on CT {
+ var SoI vl_cs := {0,1,2,3,4,5,6,7};
+ var SoI vl_bs := substr(vl_cs, 3,4)
+ if(vl_bs!={3,4,5,6}){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_SoI5() runs on CT {
+ const SoI vl_cs := {0,1,2,3,4,5,6,7};
+ const SoI vl_bs := substr(vl_cs, 3, 5)
+ if(vl_bs!={3,4,5,6,7}){
+ setverdict(fail);
+ }
+
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_SoI6() runs on CT {
+ var SoI vl_cs := {0,1,2,3,4,5,6,7};
+ var SoI vl_bs := substr(vl_cs, 3,5)
+ if(vl_bs!={3,4,5,6,7}){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_SoI6a() runs on CT {
+ const SoI vl_cs := {0,1,2,3,4,5,6,7};
+ const SoI vl_bs := substr(vl_cs, 8,0)
+ if(vl_bs!={}){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+testcase tc_predef_substring_SoI6b() runs on CT {
+ var SoI vl_cs := {0,1,2,3,4,5,6,7};
+ var SoI vl_bs := substr(vl_cs, 8,0)
+ if(vl_bs!={}){
+ setverdict(fail);
+ }
+ log(vl_bs);
+ setverdict(pass);
+}
+
+
+
+//semantic error (before compile time)
+//testcase tc_predef_substring_SoI7() runs on CT {
+// const SoI vl_cs := {0,1,2,3,4,5,6,7};
+// const SoI vl_bs := substr(vl_cs, 3, 6)
+// setverdict(fail);
+//}
+//runtime error
+testcase tc_predef_substring_SoI8() runs on CT {
+ var SoI vl_cs := {0,1,2,3,4,5,6,7};
+ @try {
+ var SoI vl_bs := substr(vl_cs, 3,6)
+ setverdict(fail,"DTE expected");
+ }
+ @catch(e){
+ setverdict(pass);
+ }
+}
+
+//semantic error (before compile time)
+//testcase tc_predef_substring_SoI9() runs on CT {
+// const SoI vl_cs := {0,1,2,3,4,5,6,7};
+// const SoI vl_bs := substr(vl_cs, 9, 0)
+// setverdict(fail);
+//}
+//runtime error
+testcase tc_predef_substring_SoI10() runs on CT {
+ var SoI vl_cs := {0,1,2,3,4,5,6,7};
+ @try {
+ var SoI vl_bs := substr(vl_cs, 9,0)
+ setverdict(fail,"DTE expected");
+ }
+ @catch(e){
+ setverdict(pass);
+ }
+}
+
+//unichar2char
+//unichar2int
+
+control{
+ execute(tc_predef_str2float_empty());
+ execute(tc_predef_str2float_empty2());
+ execute( tc_predef_str2float_good1());
+ execute( tc_predef_str2float_good2());
+ execute( tc_predef_str2float_good2a());
+ execute( tc_predef_str2float_good2b());
+ execute( tc_predef_str2float_good2c());
+ execute( tc_predef_str2float_good2d());
+ execute( tc_predef_str2float_good3());
+ execute( tc_predef_str2float_good3b());
+ execute( tc_predef_str2float_good4());
+ execute( tc_predef_str2float_good4b());
+ execute( tc_predef_str2float_good4c());
+ execute( tc_predef_str2float_good5());
+ execute(tc_predef_str2float_bad1());
+ // execute(tc_predef_str2float_bad1b()); //semantic error
+ execute(tc_predef_str2float_bad2());
+ execute(tc_predef_str2float_bad3());
+ execute(tc_predef_str2float_bad4());
+ execute( tc_predef_rnd());
+ execute( tc_predef_bit2hex1());
+ execute( tc_predef_bit2hex2());
+ execute(tc_predef_bit2hex_bitstr_element());
+ execute(tc_predef_bit2oct1());
+ execute(tc_predef_bit2oct2());
+ execute(tc_predef_bit2oct_bitstr_element())
+ execute(tc_predef_bit2int_good());
+ execute(tc_predef_bit2int_good_with_space());
+ execute(tc_predef_bit2int_good_long1());
+ execute(tc_predef_bit2int_good_long2());
+ execute(tc_predef_bit2int_good_long3());
+ execute(tc_predef_bit2int_good_long4());
+ execute(tc_predef_bit2int_good_long5());
+ execute(tc_predef_bit2int_bitstr_element());
+ // execute(tc_predef_bit2int_good_with_whitespace());
+ execute(tc_predef_bit2int_good_empty());
+ execute(tc_predef_bit2oct_good());
+ execute(tc_predef_bit2oct_good_with_space());
+ execute(tc_predef_bit2oct_bitstr_element());
+ execute(tc_predef_bit2str_good());
+ execute(tc_predef_bit2str_good_with_space());
+ execute(tc_predef_bit2str_good_empty());
+ execute(tc_predef_bit2str_bitstr_element());
+ execute(tc_predef_char2int_good());
+ execute(tc_predef_char2int_good_charstring_element());
+ execute(tc_predef_char2int_bad1());
+ execute(tc_predef_char2int_bad2());
+ execute(tc_predef_char2int_bad3());
+ execute(tc_predef_char2int_bad4());
+ execute(tc_predef_char2oct_good1());
+ execute(tc_predef_char2oct_charstring_element());
+ execute(tc_predef_char2oct_good_empty());
+ execute(tc_predef_float2int_good1());
+ execute(tc_predef_float2int_bad1());
+ execute(tc_predef_float2str_good0());
+ execute(tc_predef_float2str_good1());
+ execute(tc_predef_float2str_good2());
+ execute(tc_predef_float2str_good3());
+ execute(tc_predef_float2str_good4());
+ execute(tc_predef_float2str_good5());
+ execute(tc_predef_float2str_good6());
+ execute(tc_predef_float2str_good7());
+ execute(tc_predef_float2str_good8());
+ execute(tc_predef_float2str_good9());
+ execute(tc_predef_float2str_good10());
+ execute(tc_predef_float2str_good11());
+ execute(tc_predef_float2str_good12());
+ execute(tc_predef_float2str_good13());
+ execute(tc_predef_float2str_good14());
+ execute(tc_predef_float2str_good15());
+ execute(tc_predef_float2str_good16());
+ execute(tc_predef_hex2bit_empty1());
+ execute(tc_predef_hex2bit_empty2());
+ execute(tc_predef_hex2bit_unbound());
+ execute(tc_predef_hex2bit_good1());
+ execute(tc_predef_hex2bit_good2());
+ execute(tc_predef_hex2bit_good20());
+ execute(tc_predef_hex2bit_hexstr_element());
+ execute(tc_predef_hex2int_unbound());
+ execute(tc_predef_hex2int_empty());
+ execute(tc_predef_hex2int_good1());
+ execute(tc_predef_hex2int_good2());
+ execute(tc_predef_hex2int_good3());
+ execute(tc_predef_hex2int_hexstr_element());
+ execute(tc_predef_hex2oct_empty1());
+ execute(tc_predef_hex2oct_empty2());
+ execute(tc_predef_hex2oct_unbound());
+ execute(tc_predef_hex2oct_good1());
+ execute(tc_predef_hex2oct_good2());
+ execute(tc_predef_hex2oct_good3());
+ execute(tc_predef_hex2oct_good4());
+ execute(tc_predef_hex2oct_good5());
+ execute(tc_predef_hex2oct_good6());
+ execute(tc_predef_hex2oct_good7());
+ execute(tc_predef_hex2oct_hexstr_element());
+
+ execute(tc_predef_hex2str_empty1());
+ execute(tc_predef_hex2str_unbound());
+ execute(tc_predef_hex2str_good1());
+ execute(tc_predef_hex2str_good2());
+ execute(tc_predef_hex2str_good3());
+ execute(tc_predef_hex2str_good4());
+ execute(tc_predef_hex2str_good5());
+ execute(tc_predef_hex2str_good6());
+ execute(tc_predef_hex2str_good7());
+ execute(tc_predef_hex2str_hexstring_element());
+
+ execute(tc_predef_int2bit_unbound());
+ execute(tc_predef_int2bit_wrongLength());
+ execute(tc_predef_int2bit_negLength());
+ execute(tc_predef_int2bit_negInt());
+ 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_int2hex_bad4());
+
+ 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_int2oct_bad5());
+ 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());//TODO: bugfix
+ //execute(tc_predef_oct2char_good2());//TODO: bugfix
+ execute(tc_predef_oct2char_bad1());
+ execute(tc_predef_oct2char_bad2());
+ execute(tc_predef_oct2char_bad3());
+ //execute(tc_predef_oct2char_octetstr_elem()); //TODO: bugfix
+ execute(tc_predef_oct2char_octetstr_elem_bad());
+ execute(tc_predef_oct2hex_good1());
+ execute(tc_predef_oct2hex_good2());
+
+ execute(tc_predef_oct2int_good1());
+ execute(tc_predef_oct2int_good1a());
+ execute(tc_predef_oct2int_good1b());
+ execute(tc_predef_oct2int_good2());
+ execute(tc_predef_oct2int_empty());
+
+ execute(tc_predef_oct2str_good1());
+ execute(tc_predef_oct2str_good2());
+ execute(tc_predef_oct2str_octetstring_element());
+
+ execute(tc_predef_replace_bitstring_1());
+ execute(tc_predef_replace_bitstring_1a());
+ execute(tc_predef_replace_bitstring_1b());
+ execute(tc_predef_replace_bitstring_2());
+ execute(tc_predef_replace_bitstring_2a());
+ execute(tc_predef_replace_bitstring_3());
+ execute(tc_predef_replace_bitstring_4());
+ execute(tc_predef_replace_bitstring_5());
+ execute(tc_predef_replace_bitstring_6());
+ execute(tc_predef_replace_bitstring_7());
+ execute(tc_predef_replace_bitstring_8());
+ execute(tc_predef_replace_bitstring_9());
+ // execute(tc_predef_replace_bitstring_10());
+ execute(tc_predef_replace_bitstring_11());
+ // execute(tc_predef_replace_bitstring_12());
+ execute(tc_predef_replace_bitstring_14_bad());
+ execute(tc_predef_replace_bitstring_16_bad());
+ execute(tc_predef_replace_bitstring_18_bad());
+ execute(tc_predef_replace_bitstring_19_bad());
+ execute(tc_predef_replace_bitstring_20_bad());
+ execute(tc_predef_replace_bitstring_21_bad());
+ execute(tc_predef_replace_bitstring_22_bad());
+ execute(tc_predef_replace_bitstring_23());
+ execute(tc_predef_replace_bitstring_24());
+ //===
+ execute(tc_predef_replace_hexstring_1());
+ execute(tc_predef_replace_hexstring_1a());
+ execute(tc_predef_replace_hexstring_1b());
+ execute(tc_predef_replace_hexstring_2());
+ execute(tc_predef_replace_hexstring_2a());
+ execute(tc_predef_replace_hexstring_3());
+ execute(tc_predef_replace_hexstring_4());
+ execute(tc_predef_replace_hexstring_5());
+ execute(tc_predef_replace_hexstring_6());
+ execute(tc_predef_replace_hexstring_7());
+ execute(tc_predef_replace_hexstring_8());
+ execute(tc_predef_replace_hexstring_9());
+ execute(tc_predef_replace_hexstring_10());
+ execute(tc_predef_replace_hexstring_11());
+ execute(tc_predef_replace_hexstring_12());
+ execute(tc_predef_replace_hexstring_14_bad());
+ execute(tc_predef_replace_hexstring_16_bad());
+ execute(tc_predef_replace_hexstring_18_bad());
+ execute(tc_predef_replace_hexstring_19());
+ execute(tc_predef_replace_hexstring_20());
+ execute(tc_predef_replace_hexstring_21());
+ execute(tc_predef_replace_hexstring_22());
+ execute(tc_predef_replace_hexstring_23());
+ execute(tc_predef_replace_hexstring_24());
+ execute(tc_predef_replace_hexstring_25());
+ execute(tc_predef_replace_hexstring_26());
+
+ //===
+ execute(tc_predef_replace_octetstring_1());
+ execute(tc_predef_replace_octetstring_1a());
+ execute(tc_predef_replace_octetstring_1b());
+ execute(tc_predef_replace_octetstring_2());
+ execute(tc_predef_replace_octetstring_2a());
+ execute(tc_predef_replace_octetstring_3());
+ execute(tc_predef_replace_octetstring_4());
+ execute(tc_predef_replace_octetstring_5());
+ execute(tc_predef_replace_octetstring_6());
+ execute(tc_predef_replace_octetstring_7());
+ execute(tc_predef_replace_octetstring_8());
+ execute(tc_predef_replace_octetstring_9());
+ execute(tc_predef_replace_octetstring_10());
+ execute(tc_predef_replace_octetstring_11());
+ execute(tc_predef_replace_octetstring_12());
+ execute(tc_predef_replace_octetstring_14_bad());
+ execute(tc_predef_replace_octetstring_16_bad());
+ execute(tc_predef_replace_octetstring_18_bad());
+ execute(tc_predef_replace_octetstring_19_bad());
+ execute(tc_predef_replace_octetstring_20_bad());
+ execute(tc_predef_replace_octetstring_21_bad());
+ execute(tc_predef_replace_octetstring_22_bad());
+ execute(tc_predef_replace_octetstring_23_bad());
+ execute(tc_predef_replace_octetstring_24_bad());
+ execute(tc_predef_replace_octetstring_25());
+ execute(tc_predef_replace_octetstring_26());
+ //===
+ execute(tc_predef_replace_charstring_1());
+ execute(tc_predef_replace_charstring_1a());
+ execute(tc_predef_replace_charstring_1b());
+ execute(tc_predef_replace_charstring_2());
+ execute(tc_predef_replace_charstring_2a());
+ execute(tc_predef_replace_charstring_3());
+ execute(tc_predef_replace_charstring_4());
+ execute(tc_predef_replace_charstring_5());
+ execute(tc_predef_replace_charstring_6());
+ execute(tc_predef_replace_charstring_7());
+ execute(tc_predef_replace_charstring_8());
+ execute(tc_predef_replace_charstring_9());
+ execute(tc_predef_replace_charstring_10());
+ execute(tc_predef_replace_charstring_11());
+ execute(tc_predef_replace_charstring_12());
+ execute(tc_predef_replace_charstring_14_bad());
+ execute(tc_predef_replace_charstring_16_bad());
+ execute(tc_predef_replace_charstring_17_bad());
+ execute(tc_predef_replace_charstring_18());
+ execute(tc_predef_replace_charstring_19_bad());
+ execute(tc_predef_replace_charstring_20_bad());
+ execute(tc_predef_replace_charstring_21_bad());
+ execute(tc_predef_replace_charstring_22_bad());
+ execute(tc_predef_replace_charstring_23_bad());
+ execute(tc_predef_replace_charstring_24_bad());
+ execute(tc_predef_replace_charstring_25());
+ execute(tc_predef_replace_charstring_26());
+ execute(tc_predef_replace_charstring_27_bad());
+ execute(tc_predef_replace_charstring_28_bad());
+ //=== uchar
+ execute(tc_predef_replace_ucharstring_1());
+ execute(tc_predef_replace_ucharstring_1a());
+ execute(tc_predef_replace_ucharstring_1b());
+ execute(tc_predef_replace_ucharstring_2());
+ execute(tc_predef_replace_ucharstring_2a());
+ execute(tc_predef_replace_ucharstring_3());
+ execute(tc_predef_replace_ucharstring_4());
+ execute(tc_predef_replace_ucharstring_5());
+ execute(tc_predef_replace_ucharstring_6());
+ execute(tc_predef_replace_ucharstring_7());
+ execute(tc_predef_replace_ucharstring_8());
+ execute(tc_predef_replace_ucharstring_9());
+ execute(tc_predef_replace_ucharstring_10());
+ execute(tc_predef_replace_ucharstring_11());
+ execute(tc_predef_replace_ucharstring_12());
+ execute(tc_predef_replace_ucharstring_14_bad());
+ execute(tc_predef_replace_ucharstring_16_bad());
+ execute(tc_predef_replace_ucharstring_17_bad());
+ execute(tc_predef_replace_ucharstring_18());
+ execute(tc_predef_replace_ucharstring_18a());
+ execute(tc_predef_replace_ucharstring_18b());
+ execute(tc_predef_replace_ucharstring_19_bad());
+ execute(tc_predef_replace_ucharstring_20_bad());
+ execute(tc_predef_replace_ucharstring_21_bad());
+ execute(tc_predef_replace_ucharstring_22_bad());
+ execute(tc_predef_replace_ucharstring_23_bad());
+ execute(tc_predef_replace_ucharstring_24_bad());
+ execute(tc_predef_replace_ucharstring_25());
+ execute(tc_predef_replace_ucharstring_26());
+ execute(tc_predef_replace_ucharstring_27_bad());
+ execute(tc_predef_replace_ucharstring_28_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());
+}
+}
+