diff --git a/Regression_Test_java/.TITAN_properties b/Regression_Test_java/.TITAN_properties
new file mode 100644
index 0000000000000000000000000000000000000000..c9d30bd4ed8a14cef5df752a2a25da942b269085
--- /dev/null
+++ b/Regression_Test_java/.TITAN_properties
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<TITAN_Designer_Properties>
+ <ActiveConfiguration>Default</ActiveConfiguration>
+ <ProjectProperties>
+ <MakefileSettings>
+ <GNUMake>true</GNUMake>
+ <incrementalDependencyRefresh>true</incrementalDependencyRefresh>
+ <targetExecutable>bin/regressionTestSmall</targetExecutable>
+ <omitInValueList>true</omitInValueList>
+ </MakefileSettings>
+ <LocalBuildSettings>
+ <MakefileScript/>
+ <workingDirectory>java_src</workingDirectory>
+ </LocalBuildSettings>
+ </ProjectProperties>
+ <FileProperties>
+ <FileResource>
+ <FilePath>src/TverdictOper.ttcn</FilePath>
+ <FileProperties>
+ <ExcludeFromBuild>true</ExcludeFromBuild>
+ </FileProperties>
+ </FileResource>
+ </FileProperties>
+</TITAN_Designer_Properties>
\ No newline at end of file
diff --git a/Regression_Test_java/.classpath b/Regression_Test_java/.classpath
new file mode 100644
index 0000000000000000000000000000000000000000..0181d30e7bc812ccb40a28208717a6c9dc85f642
--- /dev/null
+++ b/Regression_Test_java/.classpath
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+ <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
+ <classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+ <classpathentry kind="src" path="java_src"/>
+ <classpathentry kind="src" path="src2"/>
+ <classpathentry kind="output" path="java_bin"/>
+</classpath>
diff --git a/Regression_Test_java/.gitignore b/Regression_Test_java/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..7ca7b4705e8c42094d21ae55a9f723941dcd5738
--- /dev/null
+++ b/Regression_Test_java/.gitignore
@@ -0,0 +1 @@
+/java_bin/
diff --git a/Regression_Test_java/.project b/Regression_Test_java/.project
new file mode 100644
index 0000000000000000000000000000000000000000..4cb796111764495b488974e781e58d8940c19620
--- /dev/null
+++ b/Regression_Test_java/.project
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+ <name>Regression_Test_java</name>
+ <comment></comment>
+ <projects>
+ </projects>
+ <buildSpec>
+ <buildCommand>
+ <name>org.eclipse.titan.designer.core.TITANJavaBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.jdt.core.javabuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.ManifestBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ <buildCommand>
+ <name>org.eclipse.pde.SchemaBuilder</name>
+ <arguments>
+ </arguments>
+ </buildCommand>
+ </buildSpec>
+ <natures>
+ <nature>org.eclipse.titan.designer.core.TITANNature</nature>
+ <nature>org.eclipse.jdt.core.javanature</nature>
+ <nature>org.eclipse.pde.PluginNature</nature>
+ </natures>
+</projectDescription>
diff --git a/Regression_Test_java/META-INF/MANIFEST.MF b/Regression_Test_java/META-INF/MANIFEST.MF
new file mode 100644
index 0000000000000000000000000000000000000000..ce7d23bafc15f2fde39a20a2015194d535c47a9c
--- /dev/null
+++ b/Regression_Test_java/META-INF/MANIFEST.MF
@@ -0,0 +1,11 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Regression_Test_java
+Bundle-SymbolicName: Regression_Test_java;singleton:=true
+Bundle-Version: 1.0.0
+Require-Bundle: org.eclipse.titan.runtime;bundle-version="1.0.0",
+ org.antlr.runtime;bundle-version="4.3.0"
+Bundle-RequiredExecutionEnvironment: JavaSE-1.6
+Bundle-ActivationPolicy: lazy
+Export-Package: org.eclipse.titan.Regression_Test_java.generated,
+ org.eclipse.titan.Regression_Test_java.user_provided
diff --git a/Regression_Test_java/build.properties b/Regression_Test_java/build.properties
new file mode 100644
index 0000000000000000000000000000000000000000..a7527468adee7ee6d7b3e0a9419312a952711773
--- /dev/null
+++ b/Regression_Test_java/build.properties
@@ -0,0 +1,7 @@
+source.. = java_src/
+output.. = java_bin/
+bin.includes = META-INF/,\
+ .,\
+ java_src/,\
+ src2/,\
+ .classpath
diff --git a/Regression_Test_java/single_config.cfg b/Regression_Test_java/single_config.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a807454aac9aa3bacf0d6972555eb8699ce5c080
--- /dev/null
+++ b/Regression_Test_java/single_config.cfg
@@ -0,0 +1,109 @@
+[MODULE_PARAMETERS]
+# This section shall contain the values of all parameters that are defined in your TTCN-3 modules.
+
+[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).
+
+LogFile := "logs/%e.%h-%r.%s"
+FileMask := LOG_ALL #|TESTCASE | STATISTICS #|LOG_ALL #| DEBUG | MATCHING
+ConsoleMask := ERROR | WARNING | TESTCASE | STATISTICS #| PORTEVENT | USER
+LogSourceInfo := Yes
+AppendFile := No
+TimeStampFormat := Time
+LogEventTypes := No
+SourceInfoFormat := Single
+LogEntityName := Yes
+
+
+[EXECUTE]
+all_from_subrefs.control
+hex_to_OK.control
+#functions.control
+TtemplateAnytype.control
+TtemplateInt.control
+replacer_OK.control
+TintOper.control
+TtemplateFloat.control
+TbasicStatem.control
+hex_to_SW.control
+TtemplateChar.control
+#tryCatch_Functions.control
+TtemplateBool.control
+float_to_OK.control
+int_to_SW.control
+all_from_subtype.control
+all_from_with_functions.control
+TcharOper.control
+all_from_var.control
+float_to_SW.control
+TcontrolTimer.control
+TrecofOper.control
+int_to_OK.control
+SelectUnion.control
+TtemplateEnum.control
+TcharstrOper.control
+TtemplateRec.control
+rotter_SW.control
+TassignmentNotation.control
+IsTemplateKind.control
+rotter_OK.control
+ExclusiveRangeTemplate.control
+size_of_SW.control
+TtemplateBitstr.control
+all_from_subset.control
+size_of_OK.control
+TucharstrOper.control
+TsetofMatch.control
+ThexstrOper.control
+bit_to_SW.control
+TunionOper.control
+TrecordOper.control
+TenumOper.control
+tcname_SW.control
+TanytypeOper.control
+TfloatOper.control
+TbitstrOper.control
+all_from_superset.control
+bit_to_OK.control
+TobjidOper.control
+#imported_templates.control
+TsetOper.control
+tcname_OK.control
+char_to_OK.control
+TtemplateSetof.control
+TboolOper.control
+enum_to_OK.control
+shifty_SW.control
+ToctetstrOper.control
+TfloatOperSpecial.control
+char_to_SW.control
+FuncRef.control
+isprecho_OK.control
+shifty_OK.control
+TtemplateUnion.control
+TarrayOper.control
+#everything.control
+#types.control
+sub_str_SW.control
+TdefaultOper.control
+str_to_SW.control
+all_from_complement.control
+TlostTimer.control
+RAWCodingAttributes.control
+#TtemplateRecAsn.control
+enum_to_SW.control
+all_from_permutation.control
+TtemplateSet.control
+oct_to_SW.control
+sapc.control
+TtemplateRecof.control
+#ASN_Definitions.control
+oct_to_OK.control
+sub_str_OK.control
+TanytypeWrapOper.control
+#ImportedTemplates.control
+TsetofOper.control
+all_from.control
+str_to_OK.control
+replacer_SW.control
diff --git a/Regression_Test_java/src/ExclusiveRangeTemplate.ttcn b/Regression_Test_java/src/ExclusiveRangeTemplate.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..53a27890c8ce6dc41ea8f45af22620b35f11abf2
--- /dev/null
+++ b/Regression_Test_java/src/ExclusiveRangeTemplate.ttcn
@@ -0,0 +1,413 @@
+/******************************************************************************
+ * 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:
+ * Szabo, Bence Janos
+ *
+ ******************************************************************************/
+module ExclusiveRangeTemplate {
+
+type component EmptyCT {}
+
+
+testcase tc_integer() runs on EmptyCT {
+
+ template integer positive_templ:= (!1 .. !10);
+ var integer f := 10;
+ if (match(f, positive_templ)) {
+ setverdict(fail, match(f, positive_templ));
+ }
+ f := 1;
+ if (match(f, positive_templ)) {
+ setverdict(fail, match(f, positive_templ));
+ }
+ f := 0;
+ if (match(f, positive_templ)) {
+ setverdict(fail, match(f, positive_templ));
+ }
+ f := 2;
+ if (match(f, positive_templ) == false) {
+ setverdict(fail, match(f, positive_templ));
+ }
+ f := 9;
+ if (match(f, positive_templ) == false) {
+ setverdict(fail, match(f, positive_templ));
+ }
+
+ if ("(!1 .. !10)" != log2str(positive_templ)) {
+ setverdict(fail, match("(!1 .. !10)", log2str(positive_templ)));
+ }
+ template integer copy_positive_templ := positive_templ;
+ if (log2str(positive_templ) != log2str(copy_positive_templ)) {
+ setverdict(fail, match(log2str(positive_templ), log2str(copy_positive_templ)));
+ }
+
+ var template integer tmp;
+// string2ttcn(ttcn2string(positive_templ), tmp);
+// if (log2str(positive_templ) != log2str(tmp)) {
+// setverdict(fail, "Expected: ", positive_templ, " Got: ", tmp);
+// }
+
+ template integer negative_templ:= (!-10 .. !-1);
+ f := -10;
+ if (match(f, negative_templ)) {
+ setverdict(fail, match(f, negative_templ));
+ }
+ f := -1;
+ if (match(f, negative_templ)) {
+ setverdict(fail, match(f, negative_templ));
+ }
+ f := 0;
+ if (match(f, negative_templ)) {
+ setverdict(fail, match(f, negative_templ));
+ }
+ f := -1;
+ if (match(f, negative_templ)) {
+ setverdict(fail, match(f, negative_templ));
+ }
+ f := -2;
+ if (match(f, negative_templ) == false) {
+ setverdict(fail, match(f, negative_templ));
+ }
+ f := -9;
+ if (match(f, negative_templ) == false) {
+ setverdict(fail, match(f, negative_templ));
+ }
+
+ if ("(!-10 .. !-1)" != log2str(negative_templ)) {
+ setverdict(fail, match("(!-10 .. !-1)", log2str(negative_templ)));
+ }
+ template integer copy_negative_templ := negative_templ;
+ if (log2str(negative_templ) != log2str(copy_negative_templ)) {
+ setverdict(fail, match(log2str(negative_templ), log2str(copy_negative_templ)));
+ }
+
+ setverdict(pass);
+}
+
+testcase tc_float() runs on EmptyCT {
+
+ template float positive_templ:= (!1.0 .. !10.0);
+ var float f := 10.0;
+ if (match(f, positive_templ)) {
+ setverdict(fail, match(f, positive_templ));
+ }
+ f := 1.0;
+ if (match(f, positive_templ)) {
+ setverdict(fail, match(f, positive_templ));
+ }
+ f := 0.0;
+ if (match(f, positive_templ)) {
+ setverdict(fail, match(f, positive_templ));
+ }
+ f := 1.0;
+ if (match(f, 11.0)) {
+ setverdict(fail, match(f, positive_templ));
+ }
+ f := 2.0;
+ if (match(f, positive_templ) == false) {
+ setverdict(fail, match(f, positive_templ));
+ }
+ f := 9.0;
+ if (match(f, positive_templ) == false) {
+ setverdict(fail, match(f, positive_templ));
+ }
+
+ if ("(!1.000000 .. !10.000000)" != log2str(positive_templ)) {
+ setverdict(fail, match("(!1.000000 .. !10.000000)", log2str(positive_templ)));
+ }
+ template float copy_positive_templ := positive_templ;
+ if (log2str(positive_templ) != log2str(copy_positive_templ)) {
+ setverdict(fail, match(log2str(positive_templ), log2str(copy_positive_templ)));
+ }
+
+ var template float tmp;
+// string2ttcn(ttcn2string(positive_templ), tmp);
+// if (log2str(positive_templ) != log2str(tmp)) {
+// setverdict(fail, "Expected: ", positive_templ, " Got: ", tmp);
+// }
+
+ template float negative_templ := (!-10.0 .. !-1.0);
+ f := -10.0;
+ if (match(f, negative_templ)) {
+ setverdict(fail, match(f, negative_templ));
+ }
+ f := -1.0;
+ if (match(f, negative_templ)) {
+ setverdict(fail, match(f, negative_templ));
+ }
+ f := -0.0;
+ if (match(f, negative_templ)) {
+ setverdict(fail, match(f, negative_templ));
+ }
+ f := -11.0;
+ if (match(f, negative_templ)) {
+ setverdict(fail, match(f, negative_templ));
+ }
+ f := -2.0;
+ if (match(f, negative_templ) == false) {
+ setverdict(fail, match(f, negative_templ));
+ }
+ f := -9.0;
+ if (match(f, negative_templ) == false) {
+ setverdict(fail, match(f, negative_templ));
+ }
+ f := -5.0;
+ if (match(f, negative_templ) == false) {
+ setverdict(fail, match(f, negative_templ));
+ }
+
+ if ("(!-10.000000 .. !-1.000000)" != log2str(negative_templ)) {
+ setverdict(fail, match("(!-10.000000 .. !-1.000000)", log2str(negative_templ)));
+ }
+ template float copy_negative_templ := negative_templ;
+ if (log2str(negative_templ) != log2str(copy_negative_templ)) {
+ setverdict(fail, match(log2str(negative_templ), log2str(copy_negative_templ)));
+ }
+
+// string2ttcn(ttcn2string(negative_templ), tmp);
+// if (log2str(negative_templ) != log2str(tmp)) {
+// setverdict(fail, "Expected: ", negative_templ, " Got: ", tmp);
+// }
+
+ template float infinity_templ := (!-infinity .. !infinity);
+ if (match(f, infinity_templ) == false) {
+ setverdict(fail, match(f, infinity_templ));
+ }
+ f := -infinity;
+ if (match(f, infinity_templ)) {
+ setverdict(fail, match(f, infinity_templ));
+ }
+ f := infinity;
+ if (match(f, infinity_templ)) {
+ setverdict(fail, match(f, infinity_templ));
+ }
+
+ if ("(!-infinity .. !infinity)" != log2str(infinity_templ)) {
+ setverdict(fail, match("(!-infinity .. !infinity)", log2str(infinity_templ)));
+ }
+ template float copy_infinity_templ := infinity_templ;
+ if (log2str(infinity_templ) != log2str(copy_infinity_templ)) {
+ setverdict(fail, match(log2str(infinity_templ), log2str(copy_infinity_templ)));
+ }
+
+ setverdict(pass);
+}
+
+testcase tc_charstring() runs on EmptyCT {
+
+ template charstring templ:= (!"d" .. !"g");
+ var charstring f := "d";
+ if (match(f, templ)) {
+ setverdict(fail, match(f, templ));
+ }
+ f := "g";
+ if (match(f, templ)) {
+ setverdict(fail, match(f, templ));
+ }
+ f := "f";
+ if (match(f, templ) == false) {
+ setverdict(fail, match(f, templ));
+ }
+ f := "j";
+ if (match(f, templ)) {
+ setverdict(fail, match(f, templ));
+ }
+ f := "eeefff";
+ if (match(f, templ) == false) {
+ setverdict(fail, match(f, templ));
+ }
+
+ f := "dddeeefff";
+ if (match(f, templ)) {
+ setverdict(fail, match(f, templ));
+ }
+ f := "eeefffggg";
+ if (match(f, templ)) {
+ setverdict(fail, match(f, templ));
+ }
+
+ if ("(!\"d\" .. !\"g\")" != log2str(templ)) {
+ setverdict(fail, match("(!\"d\" .. !\"g\")", log2str(templ)));
+ }
+ template charstring copy_templ := templ;
+ if (log2str(templ) != log2str(copy_templ)) {
+ setverdict(fail, match(log2str(templ), log2str(copy_templ)));
+ }
+
+// var template charstring tmp;
+// string2ttcn(ttcn2string(templ), tmp);
+// if (log2str(templ) != log2str(tmp)) {
+// setverdict(fail, "Expected: ", templ, " Got: ", tmp);
+// }
+
+ setverdict(pass);
+}
+
+
+testcase tc_universal_charstring() runs on EmptyCT {
+
+ template universal charstring charstr_templ:= (!"d" .. !"g");
+ var universal charstring f := "d";
+ if (match(f, charstr_templ)) {
+ setverdict(fail, match(f, charstr_templ));
+ }
+ f := "g";
+ if (match(f, charstr_templ)) {
+ setverdict(fail, match(f, charstr_templ));
+ }
+ f := "f";
+ if (match(f, charstr_templ) == false) {
+ setverdict(fail, match(f, charstr_templ));
+ }
+ f := "j";
+ if (match(f, charstr_templ)) {
+ setverdict(fail, match(f, charstr_templ));
+ }
+ f := "eeefff";
+ if (match(f, charstr_templ) == false) {
+ setverdict(fail, match(f, charstr_templ));
+ }
+
+ f := "dddeeefff";
+ if (match(f, charstr_templ)) {
+ setverdict(fail, match(f, charstr_templ));
+ }
+ f := "eeefffggg";
+ if (match(f, charstr_templ)) {
+ setverdict(fail, match(f, charstr_templ));
+ }
+
+ if ("(!\"d\" .. !\"g\")" != log2str(charstr_templ)) {
+ setverdict(fail, match("(!\"d\" .. !\"g\")", log2str(charstr_templ)));
+ }
+ template universal charstring copy_charstr_templ := charstr_templ;
+ if (log2str(charstr_templ) != log2str(copy_charstr_templ)) {
+ setverdict(fail, match(log2str(charstr_templ), log2str(copy_charstr_templ)));
+ }
+
+ var template universal charstring tmp;
+// string2ttcn(ttcn2string(charstr_templ), tmp);
+// if (log2str(charstr_templ) != log2str(tmp)) {
+// setverdict(fail, "Expected: ", charstr_templ, " Got: ", tmp);
+// }
+
+ template universal charstring unicharstr_templ:= (!char(1,2,3,4) .. !char(1,2,4,5));
+ f := char(1,2,3,4);
+ if (match(f, unicharstr_templ)) {
+ setverdict(fail, match(f, unicharstr_templ));
+ }
+ f := char(1,2,4,5);
+ if (match(f, unicharstr_templ)) {
+ setverdict(fail, match(f, unicharstr_templ));
+ }
+ f := char(1,2,3,5);
+ if (match(f, unicharstr_templ) == false) {
+ setverdict(fail, match(f, unicharstr_templ));
+ }
+ f := char(1,2,4,4);
+ if (match(f, unicharstr_templ) == false) {
+ setverdict(fail, match(f, unicharstr_templ));
+ }
+
+ if ("(!char(1, 2, 3, 4) .. !char(1, 2, 4, 5))" != log2str(unicharstr_templ)) {
+ setverdict(fail, match("(!char(1, 2, 3, 4) .. !char(1, 2, 4, 5))", log2str(unicharstr_templ)));
+ }
+ template universal charstring copy_unicharstr_templ := unicharstr_templ;
+ if (log2str(unicharstr_templ) != log2str(copy_unicharstr_templ)) {
+ setverdict(fail, match(log2str(unicharstr_templ), log2str(copy_unicharstr_templ)));
+ }
+
+// string2ttcn(ttcn2string(unicharstr_templ), tmp);
+// if (log2str(unicharstr_templ) != log2str(tmp)) {
+// setverdict(fail, "Expected: ", unicharstr_templ, " Got: ", tmp);
+// }
+
+ setverdict(pass);
+}
+
+
+template integer positive_templ_glob:= (!1 .. !10);
+// Test that is works with global const template
+testcase tc_global_template_integer() runs on EmptyCT {
+ var integer f := 10;
+ if (match(f, positive_templ_glob)) {
+ setverdict(fail, match(f, positive_templ_glob));
+ }
+ f := 1;
+ if (match(f, positive_templ_glob)) {
+ setverdict(fail, match(f, positive_templ_glob));
+ }
+ f := 0;
+ if (match(f, positive_templ_glob)) {
+ setverdict(fail, match(f, positive_templ_glob));
+ }
+ f := 2;
+ if (match(f, positive_templ_glob) == false) {
+ setverdict(fail, match(f, positive_templ_glob));
+ }
+ f := 9;
+ if (match(f, positive_templ_glob) == false) {
+ setverdict(fail, match(f, positive_templ_glob));
+ }
+
+ if ("(!1 .. !10)" != log2str(positive_templ_glob)) {
+ setverdict(fail, match("(!1 .. !10)", log2str(positive_templ_glob)));
+ }
+ template integer copy_positive_templ := positive_templ_glob;
+ if (log2str(positive_templ_glob) != log2str(copy_positive_templ)) {
+ setverdict(fail, match(log2str(positive_templ_glob), log2str(copy_positive_templ)));
+ }
+
+ setverdict(pass);
+}
+
+// Test that it works with testcase local var template
+testcase tc_testcase_var_template_integer() runs on EmptyCT {
+ var template integer positive_templ:= (!1 .. !10);
+ var integer f := 10;
+ if (match(f, positive_templ)) {
+ setverdict(fail, match(f, positive_templ));
+ }
+ f := 1;
+ if (match(f, positive_templ)) {
+ setverdict(fail, match(f, positive_templ));
+ }
+ f := 0;
+ if (match(f, positive_templ)) {
+ setverdict(fail, match(f, positive_templ));
+ }
+ f := 2;
+ if (match(f, positive_templ) == false) {
+ setverdict(fail, match(f, positive_templ));
+ }
+ f := 9;
+ if (match(f, positive_templ) == false) {
+ setverdict(fail, match(f, positive_templ));
+ }
+
+ if ("(!1 .. !10)" != log2str(positive_templ)) {
+ setverdict(fail, match("(!1 .. !10)", log2str(positive_templ)));
+ }
+ template integer copy_positive_templ := positive_templ;
+ if (log2str(positive_templ) != log2str(copy_positive_templ)) {
+ setverdict(fail, match(log2str(positive_templ), log2str(copy_positive_templ)));
+ }
+
+ setverdict(pass);
+}
+
+control {
+ execute(tc_integer());
+ execute(tc_float());
+ execute(tc_charstring());
+ execute(tc_universal_charstring());
+ execute(tc_global_template_integer());
+ execute(tc_testcase_var_template_integer());
+}
+
+}
\ No newline at end of file
diff --git a/Regression_Test_java/src/FuncRef.ttcn b/Regression_Test_java/src/FuncRef.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..c265b513bc988baad063ca8d713cb30d4f24c5d6
--- /dev/null
+++ b/Regression_Test_java/src/FuncRef.ttcn
@@ -0,0 +1,490 @@
+/******************************************************************************
+ * 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
+ * Bartha, Norbert
+ * Delic, Adam
+ * Kovacs, Ferenc
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ * Pandi, Krisztian
+ *
+ ******************************************************************************/
+module FuncRef
+{
+
+type function un_oper(in integer a) return integer;
+type function bin_oper(in integer a, in integer b) return integer;
+
+function neg(in integer a) return integer { return -a; }
+
+function add(in integer a, in integer b) return integer { return a+b; }
+function sub(in integer a, in integer b) return integer { return a-b; }
+function mul(in integer a, in integer b) return integer { return a*b; }
+
+public function my_int2str(in integer a) return charstring {
+ var charstring f := int2str(a);
+ return f;
+}
+
+type function my_int2str_type(in integer a) return charstring;
+
+modulepar my_int2str_type modulepar_my_intstr := refers(my_int2str);
+
+
+type union operator_type
+{
+ un_oper unary,
+ bin_oper binary
+}
+
+type record of operator_type operator_list;
+type record of integer operand_list;
+
+function calculate_expr(in operand_list operands, in operator_list operators)
+return integer
+{
+ var integer operand_count := sizeof(operands);
+ var integer operator_count := sizeof(operators);
+ var integer i;
+ var integer current_operand := 1;
+ var integer result := operands[0];
+ for (i:=0; i<operator_count; i:=i+1)
+ {
+ if (ischosen(operators[i].unary))
+ {
+ result := operators[i].unary.apply(result);
+ }
+ else
+ {
+ result := operators[i].binary.apply(result, operands[current_operand]);
+ current_operand := current_operand + 1;
+ }
+ }
+ return result;
+}
+
+type component FuncRef_comp {
+ port tcport TCP1, TCP2;
+};
+
+testcase calculationTest() runs on FuncRef_comp
+{
+ var operand_list operands_1 := { 1, 2, 3 }; // -1 + 2 - 3 = -2
+ var operand_list operands_2 := { 2, 2, -6 }; // 2 * 2 + -6 = -2
+ var operator_list operators_1 := { { unary := refers(neg) },
+ { binary := refers(add) },
+ { binary := refers(sub) } };
+ var operator_list operators_2 := { { binary := refers(mul) },
+ { binary := refers(add) } };
+ var integer result_1 := calculate_expr(operands_1, operators_1);
+ var integer result_2 := calculate_expr(operands_2, operators_2);
+ if (result_1 == result_2) { setverdict(pass); }
+ else { setverdict(fail); }
+}
+
+template bin_oper bin_oper_tmpl := (refers(add), refers(sub));
+template bin_oper bin_oper_tmpl2 := *;
+template bin_oper bin_oper_tmpl3 := omit;
+
+testcase funcTemplateTest() runs on FuncRef_comp
+{
+ var bin_oper a := refers(add);
+ var bin_oper s := refers(sub);
+ var bin_oper m := refers(mul);
+ if ( match(a, bin_oper_tmpl) != match(s, bin_oper_tmpl) )
+ { setverdict(fail); }
+ if ( match(a, bin_oper_tmpl) == match(m, bin_oper_tmpl) )
+ { setverdict(fail); }
+ if ( match(s, bin_oper_tmpl) == match(m, bin_oper_tmpl) )
+ { setverdict(fail); }
+ if ( match(a, bin_oper_tmpl) != match(a, bin_oper_tmpl) )
+ { setverdict(fail); }
+ if ( match(s, bin_oper_tmpl) != match(s, bin_oper_tmpl) )
+ { setverdict(fail); }
+ if ( match(m, bin_oper_tmpl) != match(m, bin_oper_tmpl) )
+ { setverdict(fail); }
+ if (not match(m, bin_oper_tmpl2))
+ { setverdict(fail); }
+ if (match(m, bin_oper_tmpl3))
+ { setverdict(fail); }
+ setverdict(pass);
+}
+
+type function fn_type();
+function fn1() { }
+function fn2() { }
+function fn_fn(in fn_type f) return fn_type { return f; }
+template fn_type fntmpl := refers(fn1);
+
+type function fn_temp_ret_type() return template integer;
+function fn_temp_ret_fn() return template integer { return 1; }
+
+testcase funcRefOperTest() runs on FuncRef_comp
+{
+ var fn_type f1 := refers(fn1);
+ var fn_type f2 := refers(fn2);
+ const fn_type f1c := refers(fn1);
+ var fn_temp_ret_type fn_temp_ret_var := refers(fn_temp_ret_fn);
+ if (not(f1==f1)) { setverdict(fail); }
+ if (f1==f2) { setverdict(fail); }
+ if (not(f1!=f2)) { setverdict(fail); }
+ if (f1!=f1) { setverdict(fail); }
+ if (not(f1c==f1)) { setverdict(fail); }
+ if (f1c!=f1) { setverdict(fail); }
+ if (valueof(fntmpl)!=f1) { setverdict(fail); }
+ if (fn_fn(f1)!=f1) { setverdict(fail); }
+ if (fn_fn(valueof(f2))!=f2) { setverdict(fail); }
+ if (fn_fn(valueof(f2))==f1) { setverdict(fail); }
+ if(not(1 == valueof(fn_temp_ret_var.apply()))) { setverdict(fail); }
+ if(not(match(valueof(fn_temp_ret_var.apply()),fn_temp_ret_var.apply()))) { setverdict(fail); }
+ setverdict(pass);
+}
+
+type record my_message
+{
+ fn_type f
+}
+
+type port TP message {
+ inout my_message;
+} with { extension "internal" }
+
+type component main {
+ port TP tp;
+ port TP tp2;
+}
+
+template my_message msg_tmpl := ?;
+
+//testcase transferTest() runs on main {
+// connect(mtc:tp, mtc:tp2);
+// const my_message sm1 := { refers(fn1) }
+// const my_message sm2 := { refers(fn2) }
+// var my_message rm1;
+// var my_message rm2;
+// tp.send(sm1);
+// tp.send(sm2);
+// tp2.receive(msg_tmpl) -> value rm1;
+// tp2.receive(msg_tmpl) -> value rm2;
+// if (rm1==rm2) { setverdict(fail); }
+// setverdict(pass);
+//}
+
+type function fact_func_type(in integer num, inout integer steps,
+ in fact_func_type ff) return integer;
+
+function factorial1(in integer num, inout integer steps) return integer
+{
+ steps := steps + 1;
+ if (num<2) { return 1; }
+ else { return num*factorial1(num-1,steps); }
+}
+
+
+function factorial2(in integer num, inout integer steps, in fact_func_type ff)
+return integer
+{
+ steps := steps + 1;
+ if (num<2) { return 1; }
+ else { return num*ff.apply(num-1,steps,refers(factorial3)); }
+}
+
+function factorial3(in integer num, inout integer steps, in fact_func_type ff)
+return integer
+{
+ steps := steps + 1;
+ if (num<2) { return 1; }
+ else { return num*ff.apply(num-1,steps,refers(factorial2)); }
+}
+
+testcase recursiveCallTest() runs on FuncRef_comp
+{
+ var integer steps1 := 0;
+ var integer steps2 := 0;
+ if (factorial1(5,steps1) != factorial2(5,steps2,refers(factorial3)))
+ { setverdict(fail); }
+ if (steps1!=steps2) { setverdict(fail); }
+ setverdict(pass);
+}
+
+
+type function nested_rec_func(inout rec_list rl, in nested_rec_func nrf,
+ in integer depth);
+type record rec_list
+{
+ nested_rec_func nrf,
+ rec_list rl optional,
+ integer depth
+}
+function nrf_create_list_item(inout rec_list rl, in nested_rec_func nrf,
+ in integer depth)
+{
+ if (depth>0)
+ {
+ var rec_list rl2 := { rl.nrf, omit, depth-1 }
+ rl.nrf.apply(rl2, rl2.nrf, rl2.depth);
+ rl.rl := rl2;
+ }
+}
+
+testcase listRecursionTest() runs on FuncRef_comp
+{
+ var rec_list rl := { refers(nrf_create_list_item), omit, 5 }
+ rl.nrf.apply(rl, rl.nrf, rl.depth);
+ var integer expected_sum := 0+1+2+3+4+5;
+ var integer sum := rl.depth;
+ while (ispresent(rl.rl))
+ {
+ var rec_list rl2 := rl.rl;
+ rl := rl2;
+ sum := sum + rl.depth;
+ }
+ if (sum!=expected_sum) { setverdict(fail); }
+ setverdict(pass);
+}
+
+
+type function fv_type_1() return integer;
+function fv_1_1() return integer { return 11; }
+function fv_1_2() return integer { return 12; }
+type function fv_type_2() return integer;
+function fv_2_1() return integer { return 21; }
+function fv_2_2() return integer { return 22; }
+// test refers and apply operations
+testcase funcRefOperationsTest() runs on FuncRef_comp
+{
+ var fv_type_1 f11 := refers(fv_1_1);
+ var fv_type_1 f12 := refers(fv_1_2);
+ var fv_type_2 f21 := refers(fv_2_1);
+ var fv_type_2 f22 := refers(fv_2_2);
+ var template fv_type_1 tf11 := f11;
+ var template fv_type_2 tf21 := f21;
+ if (f11.apply()!=f11.apply()) { setverdict(fail); }
+ if (f11.apply()==f12.apply()) { setverdict(fail); }
+ var fv_type_1 f10 := valueof(tf11);
+ var fv_type_2 f20 := valueof(tf21);
+ if (f10.apply()!=f11.apply()) { setverdict(fail); }
+ if (f10.apply()==f12.apply()) { setverdict(fail); }
+ if (f10.apply()==f20.apply()) { setverdict(fail); }
+ if (not match(refers(fv_1_1), tf11)) { setverdict(fail); }
+ if (match(refers(fv_1_2), tf11)) { setverdict(fail); }
+ if (match(refers(fv_1_1), tf21)) { setverdict(fail); }
+ setverdict(pass);
+}
+
+
+type function fn_par() return fn_par;
+function fnp0() return fn_par { return refers(fnp0) }
+function fnp1() return fn_par { return refers(fnp1) }
+function fnp2() return fn_par { return refers(fnp2) }
+function fnp3() return fn_par { return refers(fnp3) }
+function fnp4() return fn_par { return refers(fnp4) }
+function fnpnull() return fn_par { return null; }
+function fn_params(fn_par p1, in fn_par p2, out fn_par p3, inout fn_par p4)
+{
+// if ( p1.apply()!=refers(fnp0) or p2.apply()!=refers(fnp0) or
+// p4.apply()!=refers(fnp0) ) { setverdict(fail); }
+ p1 := refers(fnp1);
+ p2 := refers(fnp2);
+ p3 := refers(fnp3);
+ p4 := refers(fnp4);
+ if (p1.apply()==null) { setverdict(fail); }
+ if (p1.apply()!=refers(fnp1)) { setverdict(fail); }
+ if (p2.apply()!=refers(fnp2)) { setverdict(fail); }
+ if (p3.apply()!=refers(fnp4)) { setverdict(fail); }
+ if (p4.apply()!=refers(fnp4)) { setverdict(fail); }
+}
+testcase funcRefParamsTest() runs on FuncRef_comp
+{
+ var fn_par fnp := refers(fnp0);
+ if (fnp0()!=refers(fnp0)) { setverdict(fail); }
+ if (fnp.apply()!=fnp0()) { setverdict(fail); }
+ if (fnp.apply()==null) { setverdict(fail); }
+ //fn_params(fnp,fnp,fnp,fnp);
+ //if (fnp.apply()!=refers(fnp4)) { setverdict(fail); }
+
+ if (fnpnull()!=null) { setverdict(fail); }
+ fnp := refers(fnpnull);
+ if (fnp.apply()!=null) { setverdict(fail); }
+ if (fnp.apply()!=fnpnull()) { setverdict(fail); }
+
+ fnp := refers(fnp0);
+ if (fnp.apply().apply().apply() != fnp.apply()) { setverdict(fail); }
+ if (fnp0().apply() != refers(fnp0)) { setverdict(fail); }
+
+ setverdict(pass);
+}
+
+
+function fff() { }
+type union UNION
+{
+ function () f1,
+ function () f2,
+ function () f3
+}
+type set SET
+{
+ function () f1 optional,
+ function () f2 optional,
+ function () f3 optional
+}
+type record REKORD
+{
+ function () f1 optional,
+ function () f2 optional,
+ function () f3 optional
+}
+// test predefined functions: sizeof(), ispresent(), ischosen()
+testcase predefFuncOnNestedCompoundTypesTest() runs on FuncRef_comp
+{
+ var REKORD v_r := { refers(fff), omit, refers(fff) }
+ var SET v_s := { f1 := refers(fff), f2 := omit, f3 := refers(fff) }
+ var UNION v_u := { f2 := refers(fff) }
+ var template REKORD t_r := v_r;
+ var template SET t_s := v_s;
+ var template UNION t_u := v_u;
+ if ( sizeof(v_r)!=2 or not ispresent(v_r.f1) or ispresent(v_r.f2) or
+ not ispresent(v_r.f3) )
+ { setverdict(fail); }
+ if ( sizeof(t_r)!=2 or not ispresent(t_r.f1) or ispresent(t_r.f2) or
+ not ispresent(t_r.f3) )
+ { setverdict(fail); }
+ if ( sizeof(v_s)!=2 or not ispresent(v_s.f1) or ispresent(v_s.f2) or
+ not ispresent(v_s.f3) )
+ { setverdict(fail); }
+ if ( sizeof(t_s)!=2 or not ispresent(t_s.f1) or ispresent(t_s.f2) or
+ not ispresent(t_s.f3) )
+ { setverdict(fail); }
+ if ( ischosen(v_u.f1) or not ischosen(v_u.f2) or ischosen(v_u.f3) )
+ { setverdict(fail); }
+ if ( ischosen(t_u.f1) or not ischosen(t_u.f2) or ischosen(t_u.f3) )
+ { setverdict(fail); }
+ setverdict(pass);
+}
+
+
+type testcase tc_type() runs on FuncRef_comp;
+type record of tc_type tc_recof;
+
+type function MyFunction_RunsOnParent() runs on Parent_CT;
+type function MyFunction_RunsOnChild() runs on Child_CT;
+type function MyFunction_RunsOnSelf() runs on self;
+
+type component Parent_CT
+{
+ var MyFunction_RunsOnParent fs_parent := null;
+ var MyFunction_RunsOnSelf fs_self := null;
+ var charstring parent := "parent";
+}
+
+type component Child_CT extends Parent_CT
+{
+ var MyFunction_RunsOnChild fs_child := null;
+ var charstring child := "child";
+}
+
+function f_parent(in MyFunction_RunsOnSelf p_self) runs on Parent_CT
+{
+ p_self.apply();
+}
+
+function f_child() runs on Child_CT
+{
+ child := "Running child function is done";
+}
+
+testcase tc_runsonself() runs on Child_CT
+{
+ fs_self := refers(f_child);
+
+ f_parent(fs_self);
+
+ if(child != "Running child function is done")
+ {
+ setverdict(fail);
+ }
+ else { setverdict(pass); }
+}
+
+type port tcport message {
+ inout tc_recof
+}
+with { extension "internal" }
+
+//testcase tc_send_tc() runs on FuncRef_comp
+//{
+// var tc_recof sent_testcases := {
+// refers(tc_send_tc)
+// }, received_testcases;
+// connect(mtc:TCP1, mtc:TCP2);
+// TCP1.send(sent_testcases);
+// TCP2.receive(tc_recof : ?) -> value received_testcases;
+// if (received_testcases == sent_testcases) { setverdict(pass); }
+// else { setverdict(fail, match(received_testcases, sent_testcases)); }
+// disconnect(mtc:TCP1, mtc:TCP2);
+//}
+
+// For TR HL26179.
+type function f_myfunctype1(in charstring p1) runs on self
+function f_myfunc1(in charstring p1) runs on empty_ct {}
+type component empty_ct {var f_myfunctype1 v_myfuncvar1 := refers(f_myfunc1)}
+
+testcase tc_functionrefIsbound() runs on FuncRef_comp
+{
+ var fv_type_1 f0;
+ var fv_type_1 f1 := refers(fv_1_1);
+ if ( isvalue(f0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(f1) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+// for TR H029700
+type function f_FT();
+
+function f_refers() {
+ var f_FT vf := valueof(f_FT:refers(f_refers));
+}
+
+// for Bug 511976
+testcase tc_modulepar_refer() runs on FuncRef_comp {
+ if (modulepar_my_intstr.apply(4) == "4") {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+
+control
+{
+ var integer i;
+ var tc_recof testcases := {
+ refers(calculationTest),
+ refers(funcTemplateTest),
+ refers(funcRefOperTest),
+ refers(recursiveCallTest),
+ refers(listRecursionTest),
+ refers(funcRefOperationsTest),
+ refers(funcRefParamsTest),
+ refers(predefFuncOnNestedCompoundTypesTest)
+ }
+ for(i := 0; i < sizeof(testcases); i := i+1)
+ {
+ execute(derefers(testcases[i])());
+ }
+// execute(transferTest());
+ execute(tc_runsonself());
+ execute(tc_functionrefIsbound());
+// execute(tc_send_tc());
+ execute(tc_modulepar_refer());
+}
+}
+
diff --git a/Regression_Test_java/src/ImportedTemplates.ttcn b/Regression_Test_java/src/ImportedTemplates.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..da4a93229bfd47adb8c1d2d60f9e6988992368db
--- /dev/null
+++ b/Regression_Test_java/src/ImportedTemplates.ttcn
@@ -0,0 +1,17 @@
+/******************************************************************************
+ * 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
+ *
+ ******************************************************************************/
+module ImportedTemplates {
+
+template integer tImported(template integer pt) := pt;
+
+}
diff --git a/Regression_Test_java/src/IsTemplateKind.ttcn b/Regression_Test_java/src/IsTemplateKind.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..2c7b8f735623c7f1c6492f2ee70428275a8a02fe
--- /dev/null
+++ b/Regression_Test_java/src/IsTemplateKind.ttcn
@@ -0,0 +1,318 @@
+/******************************************************************************
+ * 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:
+ * Szabo, Bence Janos
+ *
+ ******************************************************************************/
+
+module IsTemplateKind
+{
+
+type component MTCType {}
+
+
+type record of integer RoI;
+type set of integer SoI;
+type record of MyMessageType RoM;
+type set of MyMessageType SoM;
+type record of RoI RoRoI;
+type set of integer MySetOfType (0 .. 10);
+
+type record MyMessageType
+{
+ integer field1,
+ charstring field2,
+ boolean field3 optional,
+ integer field4[4]
+}
+
+type record MyBinaryMessage
+{
+ octetstring payload
+}
+
+type record MyPayload
+{
+ integer field1,
+ integer field2
+} with {
+ encode "XML"
+}
+
+//template octetstring mw_t1 := decmatch MyPayload:{field1 := 1, field2 := ? };
+
+
+testcase tc_istemplatekind() runs on MTCType system MTCType
+{
+var template integer vt_1 := 3;
+
+template MyMessageType vt_2 :=
+{
+ field1 := 3+2, // specific value of integer type
+ field2 := "My string", // specific value of charstring type
+ field3 := true, // specific value of boolean type
+ field4 := {1,2,3,4} // specific value of integer array
+}
+
+var template integer vt_3 := 3 ifpresent;
+var template integer vt_4 := ?;
+var template integer vt_5 := (1,2,3);
+var template RoI vt_5_5 := {1,2,3};
+var template integer vt_6 := (0, all from vt_5_5);
+var template integer vt_7 := complement(2,3,4);
+var template integer vt_8 := *;
+var template integer vt_9 := (1 .. 8);
+var template MySetOfType vt_10 := superset (1,2,3);
+var template MySetOfType vt_11 := subset (1,2,3);
+var template integer vt_12 := omit;
+
+template RoI vt_13 := {1,2,3,?};
+
+template RoI vt_14 := {1,2,3,*};
+
+template RoI vt_15 := { 3, 5, permutation(2,3,4) };
+
+template RoI vt_16 := omit;
+
+template RoI vt_17 := { 3, 5, permutation(2,3,4) } length(5..8);
+
+template RoI vt_18 := { 3, 5, permutation(2,3,4) } length(5..8) ifpresent;
+
+template charstring vt_19 := pattern "ab??xyz*0";
+
+template RoM vt_20 := { vt_2, ? };
+
+template RoRoI vt_21 := { {(3,4)}, {5,6}, ? };
+
+template MyMessageType vt_22 :=
+{
+ field1 := 3+2, // specific value of integer type
+ field2 := ?,
+ field3 := true, // specific value of boolean type
+ field4 := {1,2,3,4}
+}
+
+var boolean v_res;
+
+v_res := istemplatekind(vt_1, "value"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_2, "value"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_3, "value"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_4, "value"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_5, "list"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_1, "list"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_6, "list"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_7, "complement"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_6, "complement"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_4, "?"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_4, "AnyValue"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_3, "AnyValue"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_8, "*"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_8, "AnyValueOrNone"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_2, "AnyValueOrNone"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_9, "range"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_1, "range"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_10, "superset"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_11, "superset"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_11, "subset"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_10, "subset"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_12, "omit"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_1, "omit"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_8, "omit"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_4, "omit"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_22, "decmatch"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+//v_res := istemplatekind(mw_t1, "decmatch"); // true
+//if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_13, "AnyElement"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_20, "AnyElement"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_21, "AnyElement"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_14, "AnyElement"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_14, "AnyElementsOrNone"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_13, "AnyElementsOrNone"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_15, "permutation"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_14, "permutation"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_16, "omit"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_15, "omit"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_17, "length"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_15, "length"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_18, "ifpresent"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_17, "ifpresent"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+//v_res := istemplatekind(vt_19, "pattern"); // true
+//if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+//v_res := istemplatekind(vt_17, "pattern"); // false
+//if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_1, "AnyValue"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_1, "AnyValueOrNone"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_2, "complement"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_2, "list"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_2, "ifpresent"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_3, "permutation"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_22, "AnyElement"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+}
+
+testcase tc_istemplatekind_set() runs on MTCType system MTCType {
+template SoI vt_1 := {1,2,3,?};
+
+template SoI vt_2 := {1,2,3,*};
+
+template SoI vt_3 := omit;
+
+template SoI vt_4 := { 3, 5, 4, 6, 8 } length(5..8);
+
+template SoI vt_5 := { 3, 5, 4,5,6 } length(5..8) ifpresent;
+
+template MyMessageType vt_6 :=
+ {
+ field1 := 3+2, // specific value of integer type
+ field2 := "My string", // specific value of charstring type
+ field3 := true, // specific value of boolean type
+ field4 := {1,2,3,4} // specific value of integer array
+ }
+
+template SoM vt_7 := { vt_6, ? };
+
+var boolean v_res;
+
+
+v_res := istemplatekind(vt_1, "AnyElement"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_7, "AnyElement"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_2, "AnyElement"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_2, "AnyElementsOrNone"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_1, "AnyElementsOrNone"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_3, "omit"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_4, "omit"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_4, "length"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_2, "length"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_5, "ifpresent"); // true
+if(v_res == true) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+
+v_res := istemplatekind(vt_4, "ifpresent"); // false
+if(v_res == false) { setverdict(pass); } else { setverdict(fail,__LINE__); }
+}
+
+control
+{
+ execute(tc_istemplatekind());
+ execute(tc_istemplatekind_set());
+}
+
+}
diff --git a/Regression_Test_java/src/RAW/RAWCodingAttributes.ttcn b/Regression_Test_java/src/RAW/RAWCodingAttributes.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..ccff78950a81350abae5d720ba4788a251f9ee49
--- /dev/null
+++ b/Regression_Test_java/src/RAW/RAWCodingAttributes.ttcn
@@ -0,0 +1,7089 @@
+module RAWCodingAttributes {
+
+type component TempComp {}
+
+type integer RAW_PDU_1
+with { encode "RAW"; variant "FIELDLENGTH(16)"};
+external function enc_RAW_PDU_1(in RAW_PDU_1 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_1(in octetstring stream) return RAW_PDU_1 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_16_for_integer() runs on TempComp {
+ const RAW_PDU_1 i := 255
+ const octetstring o := 'FF00'O
+
+ if ((enc_RAW_PDU_1(i) == o)and(dec_RAW_PDU_1(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_1(i)= ", enc_RAW_PDU_1(i), "; dec_RAW_PDU_1(o)= ", dec_RAW_PDU_1(o));}
+}
+
+type integer RAW_PDU_2
+with { encode "RAW"; variant "FIELDLENGTH(8)"};
+external function enc_RAW_PDU_2(in RAW_PDU_2 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_2(in octetstring stream) return RAW_PDU_2 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_8_for_integer() runs on TempComp {
+ const RAW_PDU_2 i := 15
+ const octetstring o := '0F'O
+
+ if ((enc_RAW_PDU_2(i) == o)and(dec_RAW_PDU_2(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_2(i)= ", enc_RAW_PDU_2(i), "; dec_RAW_PDU_2(o)= ", dec_RAW_PDU_2(o));}
+}
+
+
+
+type integer RAW_PDU_3
+with { encode "RAW"; variant "FIELDLENGTH(4)"};
+external function enc_RAW_PDU_3(in RAW_PDU_3 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_3(in octetstring stream) return RAW_PDU_3 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_4_for_integer() runs on TempComp {
+ const RAW_PDU_3 i := 15
+ const octetstring o := '0F'O
+
+ if ((enc_RAW_PDU_3(i) == o)and(dec_RAW_PDU_3(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_3(i)= ", enc_RAW_PDU_3(i), "; dec_RAW_PDU_3(o)= ", dec_RAW_PDU_3(o));}
+}
+
+
+
+testcase TC_FIELDLENGTH_16_for_integer_2() runs on TempComp {
+ const RAW_PDU_1 i := 4660
+ const octetstring o := '3412'O
+
+ if ((enc_RAW_PDU_1(i) == o)and(dec_RAW_PDU_1(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_1(i)= ", enc_RAW_PDU_1(i), "; dec_RAW_PDU_1(o)= ", dec_RAW_PDU_1(o));}
+}
+
+
+
+type integer RAW_PDU_4
+with { encode "RAW"; variant "FIELDLENGTH(32)"};
+external function enc_RAW_PDU_4(in RAW_PDU_4 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_4(in octetstring stream) return RAW_PDU_4 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_32_for_integer_1_bit_long() runs on TempComp {
+ const RAW_PDU_4 i := 1
+ const octetstring o := '01000000'O
+
+ if ((enc_RAW_PDU_4(i) == o)and(dec_RAW_PDU_4(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_4(i)= ", enc_RAW_PDU_4(i), "; dec_RAW_PDU_4(o)= ", dec_RAW_PDU_4(o));}
+}
+
+
+
+type integer RAW_PDU_5
+with { encode "RAW"; variant ""};
+external function enc_RAW_PDU_5(in RAW_PDU_5 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_5(in octetstring stream) return RAW_PDU_5 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Default_FIELDLENGTH_for_integer() runs on TempComp {
+ const RAW_PDU_5 i := 255
+ const octetstring o := 'FF'O
+
+ if ((enc_RAW_PDU_5(i) == o)and(dec_RAW_PDU_5(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_5(i)= ", enc_RAW_PDU_5(i), "; dec_RAW_PDU_5(o)= ", dec_RAW_PDU_5(o));}
+}
+
+
+
+type bitstring RAW_PDU_6
+with { encode "RAW"; variant "FIELDLENGTH(8)"};
+external function enc_RAW_PDU_6(in RAW_PDU_6 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_6(in octetstring stream) return RAW_PDU_6 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_8_for_bitstring() runs on TempComp {
+ const RAW_PDU_6 i := '11110000'B
+ const octetstring o := 'F0'O
+
+ if ((enc_RAW_PDU_6(i) == o)and(dec_RAW_PDU_6(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_6(i)= ", enc_RAW_PDU_6(i), "; dec_RAW_PDU_6(o)= ", dec_RAW_PDU_6(o));}
+}
+
+
+
+type bitstring RAW_PDU_7
+with { encode "RAW"; variant "FIELDLENGTH(8)"};
+external function enc_RAW_PDU_7(in RAW_PDU_7 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_7(in octetstring stream) return RAW_PDU_7 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_8_for_bitstring_4_bits_long() runs on TempComp {
+ const RAW_PDU_7 i := '1111'B
+ const octetstring o := '0F'O
+
+ if ((enc_RAW_PDU_7(i) == o)and(dec_RAW_PDU_7(o) == '0000'B & i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_7(i)= ", enc_RAW_PDU_7(i), "; dec_RAW_PDU_7(o)= ", dec_RAW_PDU_7(o));}
+}
+
+
+
+type bitstring RAW_PDU_8
+with { encode "RAW"; variant "FIELDLENGTH(4)"};
+external function enc_RAW_PDU_8(in RAW_PDU_8 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_8(in octetstring stream) return RAW_PDU_8 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_4_for_bitstring() runs on TempComp {
+ const RAW_PDU_8 i := '1111'B
+ const octetstring o := '0F'O
+
+ if ((enc_RAW_PDU_8(i) == o)and(dec_RAW_PDU_8(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_8(i)= ", enc_RAW_PDU_8(i), "; dec_RAW_PDU_8(o)= ", dec_RAW_PDU_8(o));}
+}
+
+
+
+type bitstring RAW_PDU_9
+with { encode "RAW"; variant "FIELDLENGTH(16)"};
+external function enc_RAW_PDU_9(in RAW_PDU_9 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_9(in octetstring stream) return RAW_PDU_9 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_16_for_bitstring() runs on TempComp {
+ const RAW_PDU_9 i := '1111000001110000'B
+ const octetstring o := '70F0'O
+
+ if ((enc_RAW_PDU_9(i) == o)and(dec_RAW_PDU_9(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_9(i)= ", enc_RAW_PDU_9(i), "; dec_RAW_PDU_9(o)= ", dec_RAW_PDU_9(o));}
+}
+
+type bitstring RAW_PDU_10
+with { encode "RAW"; variant "FIELDLENGTH(24)"};
+external function enc_RAW_PDU_10(in RAW_PDU_10 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_10(in octetstring stream) return RAW_PDU_10 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_24_for_bitstring() runs on TempComp {
+ const RAW_PDU_10 i := '1111000001110000'B
+ const octetstring o := '70F000'O
+
+ if ((enc_RAW_PDU_10(i) == o)and(dec_RAW_PDU_10(o) =='00000000'B & i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_10(i)= ", enc_RAW_PDU_10(i), "; dec_RAW_PDU_10(o)= ", dec_RAW_PDU_10(o));}
+}
+
+type bitstring RAW_PDU_11
+with { encode "RAW"; variant "FIELDLENGTH(0)"};
+external function enc_RAW_PDU_11(in RAW_PDU_11 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_11(in octetstring stream) return RAW_PDU_11 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_0_for_bitstring() runs on TempComp {
+ const RAW_PDU_11 i := '1111000001110000'B
+ const octetstring o := '70F0'O
+
+ if ((enc_RAW_PDU_11(i) == o)and(dec_RAW_PDU_11(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_11(i)= ", enc_RAW_PDU_11(i), "; dec_RAW_PDU_11(o)= ", dec_RAW_PDU_11(o));}
+}
+
+
+
+type bitstring RAW_PDU_12
+with { encode "RAW"; variant ""};
+external function enc_RAW_PDU_12(in RAW_PDU_12 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_12(in octetstring stream) return RAW_PDU_12 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_DEFAULT_FIELDLENGTH_for_bitstring() runs on TempComp {
+ const RAW_PDU_12 i := '1111000001110000'B
+ const octetstring o := '70F0'O
+
+ if ((enc_RAW_PDU_12(i) == o)and(dec_RAW_PDU_12(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_12(i)= ", enc_RAW_PDU_12(i), "; dec_RAW_PDU_12(o)= ", dec_RAW_PDU_12(o));}
+}
+
+
+
+type bitstring RAW_PDU_13
+with { encode "RAW"; variant "FIELDLENGTH(32)"};
+external function enc_RAW_PDU_13(in RAW_PDU_13 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_13(in octetstring stream) return RAW_PDU_13 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_32_for_bitstring_4_bits_long() runs on TempComp {
+ const RAW_PDU_13 i := '1111'B
+ const octetstring o := '0F000000'O
+
+ if ((enc_RAW_PDU_13(i) == o)and(dec_RAW_PDU_13(o) == '0000000000000000000000000000'B & i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_13(i)= ", enc_RAW_PDU_13(i), "; dec_RAW_PDU_13(o)= ", dec_RAW_PDU_13(o));}
+}
+
+
+
+type octetstring RAW_PDU_14
+with { encode "RAW"; variant "FIELDLENGTH(1)"};
+external function enc_RAW_PDU_14(in RAW_PDU_14 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_14(in octetstring stream) return RAW_PDU_14 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_1_for_octetstring() runs on TempComp {
+ const RAW_PDU_14 i := '0F'O
+ const octetstring o := '0F'O
+
+ if ((enc_RAW_PDU_14(i) == o)and(dec_RAW_PDU_14(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_14(i)= ", enc_RAW_PDU_14(i), "; dec_RAW_PDU_14(o)= ", dec_RAW_PDU_14(o));}
+}
+
+
+
+type octetstring RAW_PDU_15
+with { encode "RAW"; variant "FIELDLENGTH(2)"};
+external function enc_RAW_PDU_15(in RAW_PDU_15 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_15(in octetstring stream) return RAW_PDU_15 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_2_for_octetstring() runs on TempComp {
+ const RAW_PDU_15 i := '1234'O
+ const octetstring o := '1234'O
+
+ if ((enc_RAW_PDU_15(i) == o)and(dec_RAW_PDU_15(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_15(i)= ", enc_RAW_PDU_15(i), "; dec_RAW_PDU_15(o)= ", dec_RAW_PDU_15(o));}
+}
+
+
+
+type octetstring RAW_PDU_16
+with { variant "FIELDLENGTH(2)";
+ variant "BYTEORDER (first)";
+ encode "RAW"
+ };
+external function enc_RAW_PDU_16(in RAW_PDU_16 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_16(in octetstring stream) return RAW_PDU_16 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_2_and_BYTEORDER_first_for_octetstring() runs on TempComp {
+ const RAW_PDU_16 i := '1234'O
+ const octetstring o := '1234'O
+
+ if ((enc_RAW_PDU_16(i) == o)and(dec_RAW_PDU_16(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_16(i)= ", enc_RAW_PDU_16(i), "; dec_RAW_PDU_16(o)= ", dec_RAW_PDU_16(o));}
+}
+
+
+
+type octetstring RAW_PDU_17
+with { variant "FIELDLENGTH(2)";
+ variant "BYTEORDER (last)";
+ encode "RAW"
+ };
+external function enc_RAW_PDU_17(in RAW_PDU_17 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_17(in octetstring stream) return RAW_PDU_17 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_2_and_BYTEORDER_last_for_octetstring() runs on TempComp {
+ const RAW_PDU_17 i := '1234'O
+ const octetstring o := '3412'O
+
+ if ((enc_RAW_PDU_17(i) == o)and(dec_RAW_PDU_17(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_17(i)= ", enc_RAW_PDU_17(i), "; dec_RAW_PDU_17(o)= ", dec_RAW_PDU_17(o));}
+}
+
+
+
+type octetstring RAW_PDU_18
+with { variant "FIELDLENGTH(4)";
+ variant "BYTEORDER (first)";
+ encode "RAW"
+ };
+external function enc_RAW_PDU_18(in RAW_PDU_18 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_18(in octetstring stream) return RAW_PDU_18 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_4_and_BYTEORDER_first_for_octetstring() runs on TempComp {
+ const RAW_PDU_18 i := '12345678'O
+ const octetstring o := '12345678'O
+
+ if ((enc_RAW_PDU_18(i) == o)and(dec_RAW_PDU_18(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_18(i)= ", enc_RAW_PDU_18(i), "; dec_RAW_PDU_18(o)= ", dec_RAW_PDU_18(o));}
+}
+
+
+
+testcase TC_FIELDLENGTH_4_for_octetstring_3_octets_long() runs on TempComp {
+ const RAW_PDU_18 i := '123456'O
+ const octetstring o := '12345600'O
+
+ if ((enc_RAW_PDU_18(i) == o)and(dec_RAW_PDU_18(o) == i & '00'O )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_18(i)= ", enc_RAW_PDU_18(i), "; dec_RAW_PDU_18(o)= ", dec_RAW_PDU_18(o));}
+}
+
+
+
+type octetstring RAW_PDU_19
+with { variant "FIELDLENGTH(5)";
+ encode "RAW"
+ };
+external function enc_RAW_PDU_19(in RAW_PDU_19 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_19(in octetstring stream) return RAW_PDU_19 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_5_for_octetstring_2_octets_long() runs on TempComp {
+ const RAW_PDU_19 i := '1234'O
+ const octetstring o := '1234000000'O
+
+ if ((enc_RAW_PDU_19(i) == o)and(dec_RAW_PDU_19(o) == i & '000000'O)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_19(i)= ", enc_RAW_PDU_19(i), "; dec_RAW_PDU_19(o)= ", dec_RAW_PDU_19(o));}
+}
+
+type octetstring RAW_PDU_20
+with { variant "FIELDLENGTH(4)";
+ variant "BYTEORDER (last)";
+ encode "RAW"
+ };
+external function enc_RAW_PDU_20(in RAW_PDU_20 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_20(in octetstring stream) return RAW_PDU_20 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_4_and_BYTEORDER_last_for_octetstring() runs on TempComp {
+ const RAW_PDU_20 i := '12345678'O
+ const octetstring o := '78563412'O
+
+ if ((enc_RAW_PDU_20(i) == o)and(dec_RAW_PDU_20(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_20(i)= ", enc_RAW_PDU_20(i), "; dec_RAW_PDU_20(o)= ", dec_RAW_PDU_20(o));}
+}
+
+
+
+testcase TC_FIELDLENGTH_4_and_BYTEORDER_last_for_octetstring_3_octets_long() runs on TempComp {
+ const RAW_PDU_20 i := '123456'O
+ const octetstring o := '00563412'O
+
+ if ((enc_RAW_PDU_20(i) == o)and(dec_RAW_PDU_20(o) == i & '00'O)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_20(i)= ", enc_RAW_PDU_20(i), "; dec_RAW_PDU_20(o)= ", dec_RAW_PDU_20(o));}
+}
+
+
+
+type octetstring RAW_PDU_21
+with { variant "";
+ encode "RAW"
+ };
+external function enc_RAW_PDU_21(in RAW_PDU_21 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_21(in octetstring stream) return RAW_PDU_21 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Default_FIELDLENGTH_for_octetstring() runs on TempComp {
+ const RAW_PDU_21 i := '123456'O
+ const octetstring o := '123456'O
+
+ if ((enc_RAW_PDU_21(i) == o)and(dec_RAW_PDU_21(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_21(i)= ", enc_RAW_PDU_21(i), "; dec_RAW_PDU_21(o)= ", dec_RAW_PDU_21(o));}
+}
+
+
+
+type octetstring RAW_PDU_22
+with { variant "FIELDLENGTH(0)";
+ encode "RAW"
+ };
+external function enc_RAW_PDU_22(in RAW_PDU_22 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_22(in octetstring stream) return RAW_PDU_22 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_0_for_octetstring() runs on TempComp {
+ const RAW_PDU_22 i := '1234'O
+ const octetstring o := '1234'O
+
+ if ((enc_RAW_PDU_22(i) == o)and(dec_RAW_PDU_22(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_22(i)= ", enc_RAW_PDU_22(i), "; dec_RAW_PDU_22(o)= ", dec_RAW_PDU_22(o));}
+}
+
+
+
+type hexstring RAW_PDU_23
+with { variant "FIELDLENGTH(4)";
+ encode "RAW"
+ };
+external function enc_RAW_PDU_23(in RAW_PDU_23 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_23(in octetstring stream) return RAW_PDU_23 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_4_for_hexstring() runs on TempComp {
+ const RAW_PDU_23 i := '1234'H
+ const octetstring o := '2143'O
+
+ if ((enc_RAW_PDU_23(i) == o)and(dec_RAW_PDU_23(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_23(i)= ", enc_RAW_PDU_23(i), "; dec_RAW_PDU_23(o)= ", dec_RAW_PDU_23(o));}
+}
+
+
+
+type hexstring RAW_PDU_24
+with { variant "FIELDLENGTH(8)";
+ encode "RAW"
+ };
+external function enc_RAW_PDU_24(in RAW_PDU_24 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_24(in octetstring stream) return RAW_PDU_24 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_8_for_hexstring() runs on TempComp {
+ const RAW_PDU_24 i := '1234'H
+ const octetstring o := '21430000'O
+
+ if ((enc_RAW_PDU_24(i) == o)and(dec_RAW_PDU_24(o) == i & '0000'H)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_24(i)= ", enc_RAW_PDU_24(i), "; dec_RAW_PDU_24(o)= ", dec_RAW_PDU_24(o));}
+}
+
+
+
+
+type hexstring RAW_PDU_25
+with { variant "";
+ encode "RAW"
+ };
+external function enc_RAW_PDU_25(in RAW_PDU_25 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_25(in octetstring stream) return RAW_PDU_25 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_DEFAULT_FIELDLENGTH_for_hexstring() runs on TempComp {
+ const RAW_PDU_25 i := '12345670'H
+ const octetstring o := '21436507'O
+
+ if ((enc_RAW_PDU_25(i) == o)and(dec_RAW_PDU_25(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_25(i)= ", enc_RAW_PDU_25(i), "; dec_RAW_PDU_25(o)= ", dec_RAW_PDU_25(o));}
+}
+
+
+
+type hexstring RAW_PDU_26
+with { variant "FIELDLENGTH(0)";
+ encode "RAW"
+ };
+external function enc_RAW_PDU_26(in RAW_PDU_26 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_26(in octetstring stream) return RAW_PDU_26 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_0_for_hexstring() runs on TempComp {
+ const RAW_PDU_26 i := '123456'H
+ const octetstring o := '214365'O
+
+ if ((enc_RAW_PDU_26(i) == o)and(dec_RAW_PDU_26(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_26(i)= ", enc_RAW_PDU_26(i), "; dec_RAW_PDU_26(o)= ", dec_RAW_PDU_26(o));}
+}
+
+
+
+type hexstring RAW_PDU_27
+with { variant "FIELDLENGTH(12)";
+ encode "RAW"
+ };
+external function enc_RAW_PDU_27(in RAW_PDU_27 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_27(in octetstring stream) return RAW_PDU_27 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_12_for_hexstring_2_hex_long() runs on TempComp {
+ const RAW_PDU_27 i := '12'H
+ const octetstring o := '210000000000'O
+
+ if ((enc_RAW_PDU_27(i) == o)and(dec_RAW_PDU_27(o) == i & '0000000000'H)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_27(i)= ", enc_RAW_PDU_27(i), "; dec_RAW_PDU_27(o)= ", dec_RAW_PDU_27(o));}
+}
+
+
+
+type enumerated RAW_PDU_28
+ { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
+ tenth }
+with { variant "FIELDLENGTH(4)" ;
+ encode "RAW"};
+external function enc_RAW_PDU_28(in RAW_PDU_28 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_28(in octetstring stream) return RAW_PDU_28 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_4_for_enumerated() runs on TempComp {
+ const RAW_PDU_28 i := first
+ const octetstring o := '01'O
+
+ if ((enc_RAW_PDU_28(i) == o)and(dec_RAW_PDU_28(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_28(i)= ", enc_RAW_PDU_28(i), "; dec_RAW_PDU_28(o)= ", dec_RAW_PDU_28(o));}
+}
+
+
+
+type enumerated RAW_PDU_29
+ { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
+ tenth }
+with { variant "FIELDLENGTH(32)" ;
+ encode "RAW"};
+external function enc_RAW_PDU_29(in RAW_PDU_29 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_29(in octetstring stream) return RAW_PDU_29 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_32_for_enumerated() runs on TempComp {
+ const RAW_PDU_29 i := first
+ const octetstring o := '01000000'O
+
+ if ((enc_RAW_PDU_29(i) == o)and(dec_RAW_PDU_29(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_29(i)= ", enc_RAW_PDU_29(i), "; dec_RAW_PDU_29(o)= ", dec_RAW_PDU_29(o));}
+}
+
+
+
+type enumerated RAW_PDU_30
+ { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
+ tenth }
+with { variant "" ;
+ encode "RAW"};
+external function enc_RAW_PDU_30(in RAW_PDU_30 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_30(in octetstring stream) return RAW_PDU_30 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Default_FIELDLENGTH_for_enumerated() runs on TempComp {
+ const RAW_PDU_30 i := tenth
+ const octetstring o := '0A'O
+
+ if ((enc_RAW_PDU_30(i) == o)and(dec_RAW_PDU_30(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_30(i)= ", enc_RAW_PDU_30(i), "; dec_RAW_PDU_30(o)= ", dec_RAW_PDU_30(o));}
+}
+
+
+
+type bitstring RAW_PDU_31 length (4);
+external function enc_RAW_PDU_31(in RAW_PDU_31 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_31(in octetstring stream) return RAW_PDU_31 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_with_length_restriction_bitstring() runs on TempComp {
+ const RAW_PDU_31 i := '1111'B
+ const octetstring o := '0F'O
+
+ if ((enc_RAW_PDU_31(i) == o)and(dec_RAW_PDU_31(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_31(i)= ", enc_RAW_PDU_31(i), "; dec_RAW_PDU_31(o)= ", dec_RAW_PDU_31(o));}
+}
+
+
+
+type hexstring RAW_PDU_32 length (0);
+external function enc_RAW_PDU_32(in RAW_PDU_32 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_32(in octetstring stream) return RAW_PDU_32 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_with_length_restriction_hexstring() runs on TempComp {
+ const RAW_PDU_32 i := ''H
+ const octetstring o := ''O
+
+ if ((enc_RAW_PDU_32(i) == o)and(dec_RAW_PDU_32(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_32(i)= ", enc_RAW_PDU_32(i), "; dec_RAW_PDU_32(o)= ", dec_RAW_PDU_32(o));}
+}
+
+
+
+type octetstring RAW_PDU_33 length (2 .. 2);
+external function enc_RAW_PDU_33(in RAW_PDU_33 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_33(in octetstring stream) return RAW_PDU_33 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_with_length_restriction_octetstring() runs on TempComp {
+ const RAW_PDU_33 i := '1122'O
+ const octetstring o := '1122'O
+
+ if ((enc_RAW_PDU_33(i) == o)and(dec_RAW_PDU_33(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_33(i)= ", enc_RAW_PDU_33(i), "; dec_RAW_PDU_33(o)= ", dec_RAW_PDU_33(o));}
+}
+
+
+type record RAW_PDU_34 {bitstring b length(4), hexstring h length(5), octetstring o length(2 .. 2)}
+with {encode "RAW"; variant ""};
+external function enc_RAW_PDU_34(in RAW_PDU_34 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_34(in octetstring stream) return RAW_PDU_34 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_with_length_restriction_record() runs on TempComp {
+ const RAW_PDU_34 i := {'1001'B,'12345'H, '1122'O}
+ const octetstring o := '1932541122'O
+
+ if ((enc_RAW_PDU_34(i) == o)and(dec_RAW_PDU_34(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_34(i)= ", enc_RAW_PDU_34(i), "; dec_RAW_PDU_34(o)= ", dec_RAW_PDU_34(o));}
+}
+
+
+
+type bitstring btype_35 length (12 .. 12);
+type record length (2 .. 2) of btype_35 RAW_PDU_35
+with {encode "RAW"; variant ""};
+external function enc_RAW_PDU_35(in RAW_PDU_35 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_35(in octetstring stream) return RAW_PDU_35 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_with_length_restriction_record_of() runs on TempComp {
+ const RAW_PDU_35 i := {'000011111111'B, '111100001111'B}
+ const octetstring o := 'FFF0F0'O
+
+ if ((enc_RAW_PDU_35(i) == o)and(dec_RAW_PDU_35(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_35(i)= ", enc_RAW_PDU_35(i), "; dec_RAW_PDU_35(o)= ", dec_RAW_PDU_35(o));}
+}
+
+
+
+type bitstring btype length (1)
+type hexstring htype length (4)
+type octetstring otype length (2 .. 2)
+
+type set RAW_PDU_36 {hexstring h length(4), octetstring o length (2 .. 2), bitstring b length(1)}
+with {encode "RAW"; variant ""};
+external function enc_RAW_PDU_36(in RAW_PDU_36 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_36(in octetstring stream) return RAW_PDU_36 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_with_length_restriction_set() runs on TempComp {
+ const RAW_PDU_36 i := {h := '1234'H, o := '1122'O, b := '1'B}
+ const octetstring o := '2143112201'O
+
+ if ((enc_RAW_PDU_36(i) == o)and(dec_RAW_PDU_36(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_36(i)= ", enc_RAW_PDU_36(i), "; dec_RAW_PDU_36(o)= ", dec_RAW_PDU_36(o));}
+}
+
+
+
+type bitstring btype_37 length (12 .. 12);
+type record length (2 .. 2) of btype_37 RAW_PDU_37
+with {encode "RAW"; variant ""};
+external function enc_RAW_PDU_37(in RAW_PDU_37 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_37(in octetstring stream) return RAW_PDU_37 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_with_length_restriction_set_of() runs on TempComp {
+ const RAW_PDU_37 i := {'000011111111'B, '111100001111'B}
+ const octetstring o := 'FFF0F0'O
+
+ if ((enc_RAW_PDU_37(i) == o)and(dec_RAW_PDU_37(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_37(i)= ", enc_RAW_PDU_37(i), "; dec_RAW_PDU_37(o)= ", dec_RAW_PDU_37(o));}
+}
+
+
+
+type bitstring RAW_PDU_38 length (9 .. 9)
+with {encode "RAW"; variant "ALIGN(left)"};
+external function enc_RAW_PDU_38(in RAW_PDU_38 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_38(in octetstring stream) return RAW_PDU_38 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_with_length_restriction_and_align_bitstring() runs on TempComp {
+ const RAW_PDU_38 i := '111100001'B
+ const octetstring o := 'E101'O
+
+ if ((enc_RAW_PDU_38(i) == o)and(dec_RAW_PDU_38(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_38(i)= ", enc_RAW_PDU_38(i), "; dec_RAW_PDU_38(o)= ", dec_RAW_PDU_38(o));}
+}
+
+
+
+type hexstring RAW_PDU_39 length (10 .. 10)
+with {encode "RAW"; variant "ALIGN(right), BITORDERINOCTET(lsb)"};
+external function enc_RAW_PDU_39(in RAW_PDU_39 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_39(in octetstring stream) return RAW_PDU_39 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_with_length_restriction_and_align_hexstring() runs on TempComp {
+ const RAW_PDU_39 i := '0000012345'H
+ const octetstring o := '0000103254000000'O
+
+ if (dec_RAW_PDU_39(o) == i) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_39(i)= ", enc_RAW_PDU_39(i), "; dec_RAW_PDU_39(o)= ", dec_RAW_PDU_39(o));}
+}
+
+
+
+type octetstring RAW_PDU_40 length (8 .. 8)
+with {encode "RAW"; variant "ALIGN(left)"};
+external function enc_RAW_PDU_40(in RAW_PDU_40 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_40(in octetstring stream) return RAW_PDU_40 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_FIELDLENGTH_with_length_restriction_and_align_octetstring() runs on TempComp {
+ const RAW_PDU_40 i := '0102030400000000'O
+ const octetstring o := '010203040000000000000000000000'O
+
+ if (dec_RAW_PDU_40(o) == i) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_40(i)= ", enc_RAW_PDU_40(i), "; dec_RAW_PDU_40(o)= ", dec_RAW_PDU_40(o));}
+}
+
+
+
+type integer RAW_PDU_41
+with {encode "RAW"; variant "BYTEORDER (first)"};
+external function enc_RAW_PDU_41(in RAW_PDU_41 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_41(in octetstring stream) return RAW_PDU_41 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_first_for_integer_0() runs on TempComp {
+ const RAW_PDU_41 i := 0
+ const octetstring o := '00'O
+
+ if ((enc_RAW_PDU_41(i) == o)and(dec_RAW_PDU_41(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_41(i)= ", enc_RAW_PDU_41(i), "; dec_RAW_PDU_41(o)= ", dec_RAW_PDU_41(o));}
+}
+
+
+
+testcase TC_BYTEORDER_first_for_integer_1() runs on TempComp {
+ const RAW_PDU_41 i := 1
+ const octetstring o := '01'O
+
+ if ((enc_RAW_PDU_41(i) == o)and(dec_RAW_PDU_41(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_41(i)= ", enc_RAW_PDU_41(i), "; dec_RAW_PDU_41(o)= ", dec_RAW_PDU_41(o));}
+}
+
+
+
+testcase TC_BYTEORDER_first_for_integer_18() runs on TempComp {
+ const RAW_PDU_41 i := 18
+ const octetstring o := '12'O
+
+ if ((enc_RAW_PDU_41(i) == o)and(dec_RAW_PDU_41(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_41(i)= ", enc_RAW_PDU_41(i), "; dec_RAW_PDU_41(o)= ", dec_RAW_PDU_41(o));}
+}
+
+
+
+type integer RAW_PDU_42
+with {encode "RAW" ;
+ variant "FIELDLENGTH (8)" ;
+ variant "BYTEORDER (first)"};
+external function enc_RAW_PDU_42(in RAW_PDU_42 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_42(in octetstring stream) return RAW_PDU_42 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_first_and_fieldlength_8_for_integer() runs on TempComp {
+ const RAW_PDU_42 i := 15
+ const octetstring o := '0F'O
+
+ if ((enc_RAW_PDU_42(i) == o)and(dec_RAW_PDU_42(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_42(i)= ", enc_RAW_PDU_42(i), "; dec_RAW_PDU_42(o)= ", dec_RAW_PDU_42(o));}
+}
+
+
+
+type integer RAW_PDU_43
+with {encode "RAW" ;
+ variant "FIELDLENGTH (16)" ;
+ variant "BYTEORDER (first)"};
+external function enc_RAW_PDU_43(in RAW_PDU_43 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_43(in octetstring stream) return RAW_PDU_43 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_first_and_fieldlength_16_for_integer() runs on TempComp {
+ const RAW_PDU_43 i := 15
+ const octetstring o := '0F00'O
+
+ if ((enc_RAW_PDU_43(i) == o)and(dec_RAW_PDU_43(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_43(i)= ", enc_RAW_PDU_43(i), "; dec_RAW_PDU_43(o)= ", dec_RAW_PDU_43(o));}
+}
+
+
+
+type integer RAW_PDU_44
+with {encode "RAW" ;
+ variant "BYTEORDER (last)"};
+external function enc_RAW_PDU_44(in RAW_PDU_44 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_44(in octetstring stream) return RAW_PDU_44 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_last_for_integer_0() runs on TempComp {
+ const RAW_PDU_44 i := 0
+ const octetstring o := '00'O
+
+ if ((enc_RAW_PDU_44(i) == o)and(dec_RAW_PDU_44(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_44(i)= ", enc_RAW_PDU_44(i), "; dec_RAW_PDU_44(o)= ", dec_RAW_PDU_44(o));}
+}
+
+
+
+testcase TC_BYTEORDER_last_for_integer_1() runs on TempComp {
+ const RAW_PDU_44 i := 1
+ const octetstring o := '01'O
+
+ if ((enc_RAW_PDU_44(i) == o)and(dec_RAW_PDU_44(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_44(i)= ", enc_RAW_PDU_44(i), "; dec_RAW_PDU_44(o)= ", dec_RAW_PDU_44(o));}
+}
+
+
+
+testcase TC_BYTEORDER_last_for_integer_18() runs on TempComp {
+ const RAW_PDU_44 i := 18
+ const octetstring o := '12'O
+
+ if ((enc_RAW_PDU_44(i) == o)and(dec_RAW_PDU_44(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_44(i)= ", enc_RAW_PDU_44(i), "; dec_RAW_PDU_44(o)= ", dec_RAW_PDU_44(o));}
+}
+
+
+
+type integer RAW_PDU_45
+with { encode "RAW";
+ variant "FIELDLENGTH (8)" ;
+ variant "BYTEORDER (last)" };
+external function enc_RAW_PDU_45(in RAW_PDU_45 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_45(in octetstring stream) return RAW_PDU_45 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_last_and_fieldlength_8_for_integer() runs on TempComp {
+ const RAW_PDU_45 i := 15
+ const octetstring o := '0F'O
+
+ if ((enc_RAW_PDU_45(i) == o)and(dec_RAW_PDU_45(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_45(i)= ", enc_RAW_PDU_45(i), "; dec_RAW_PDU_45(o)= ", dec_RAW_PDU_45(o));}
+}
+
+
+
+type integer RAW_PDU_46
+with { encode "RAW";
+ variant "FIELDLENGTH (16)" ;
+ variant "BYTEORDER (last)" };
+external function enc_RAW_PDU_46(in RAW_PDU_46 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_46(in octetstring stream) return RAW_PDU_46 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_last_and_fieldlength_16_for_integer() runs on TempComp {
+ const RAW_PDU_46 i := 15
+ const octetstring o := '000F'O
+
+ if ((enc_RAW_PDU_46(i) == o)and(dec_RAW_PDU_46(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_46(i)= ", enc_RAW_PDU_46(i), "; dec_RAW_PDU_46(o)= ", dec_RAW_PDU_46(o));}
+}
+
+
+
+type bitstring RAW_PDU_47
+with { encode "RAW";
+ variant "FIELDLENGTH(16)" ;
+ variant "BYTEORDER (first)" };
+external function enc_RAW_PDU_47(in RAW_PDU_47 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_47(in octetstring stream) return RAW_PDU_47 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_first_for_bitstring() runs on TempComp {
+ const RAW_PDU_47 i := '0000000100000010'B
+ const octetstring o := '0201'O
+
+ if ((enc_RAW_PDU_47(i) == o)and(dec_RAW_PDU_47(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_47(i)= ", enc_RAW_PDU_47(i), "; dec_RAW_PDU_47(o)= ", dec_RAW_PDU_47(o));}
+}
+
+
+
+
+type bitstring RAW_PDU_48
+with { encode "RAW";
+ variant "FIELDLENGTH(16)" ;
+ variant "BYTEORDER (last)" };
+external function enc_RAW_PDU_48(in RAW_PDU_48 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_48(in octetstring stream) return RAW_PDU_48 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_last_for_bitstring() runs on TempComp {
+ const RAW_PDU_48 i := '0000000100000010'B
+ const octetstring o := '0102'O
+
+ if ((enc_RAW_PDU_48(i) == o)and(dec_RAW_PDU_48(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_48(i)= ", enc_RAW_PDU_48(i), "; dec_RAW_PDU_48(o)= ", dec_RAW_PDU_48(o));}
+}
+
+
+
+type octetstring RAW_PDU_49
+with { encode "RAW";
+ variant "BYTEORDER (first)"};
+external function enc_RAW_PDU_49(in RAW_PDU_49 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_49(in octetstring stream) return RAW_PDU_49 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_first_for_octetstring() runs on TempComp {
+ const RAW_PDU_49 i := '1234'O
+ const octetstring o := '1234'O
+
+ if ((enc_RAW_PDU_49(i) == o)and(dec_RAW_PDU_49(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_49(i)= ", enc_RAW_PDU_49(i), "; dec_RAW_PDU_49(o)= ", dec_RAW_PDU_49(o));}
+}
+
+
+
+type octetstring RAW_PDU_50
+with { encode "RAW";
+ variant "BYTEORDER (last)"};
+external function enc_RAW_PDU_50(in RAW_PDU_50 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_50(in octetstring stream) return RAW_PDU_50 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_last_for_octetstring() runs on TempComp {
+ const RAW_PDU_50 i := '1234'O
+ const octetstring o := '3412'O
+
+ if ((enc_RAW_PDU_50(i) == o)and(dec_RAW_PDU_50(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_50(i)= ", enc_RAW_PDU_50(i), "; dec_RAW_PDU_50(o)= ", dec_RAW_PDU_50(o));}
+}
+
+
+
+type enumerated RAW_PDU_51
+ { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
+ tenth }
+with { encode "RAW";
+ variant "FIELDLENGTH(16)" ;
+ variant "BYTEORDER (first) "};
+external function enc_RAW_PDU_51(in RAW_PDU_51 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_51(in octetstring stream) return RAW_PDU_51 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_first_for_enumerated() runs on TempComp {
+ const RAW_PDU_51 i := first
+ const octetstring o := '0100'O
+
+ if ((enc_RAW_PDU_51(i) == o)and(dec_RAW_PDU_51(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_51(i)= ", enc_RAW_PDU_51(i), "; dec_RAW_PDU_51(o)= ", dec_RAW_PDU_51(o));}
+}
+
+
+
+type enumerated RAW_PDU_52
+ { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
+ tenth }
+with { encode "RAW";
+ variant "FIELDLENGTH(16)" ;
+ variant "BYTEORDER (last) "};
+external function enc_RAW_PDU_52(in RAW_PDU_52 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_52(in octetstring stream) return RAW_PDU_52 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_last_for_enumerated() runs on TempComp {
+ const RAW_PDU_52 i := first
+ const octetstring o := '0001'O
+
+ if ((enc_RAW_PDU_52(i) == o)and(dec_RAW_PDU_52(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_52(i)= ", enc_RAW_PDU_52(i), "; dec_RAW_PDU_52(o)= ", dec_RAW_PDU_52(o));}
+}
+
+
+
+type hexstring RAW_PDU_53
+with { encode "RAW"; variant "BYTEORDER(first)"};
+external function enc_RAW_PDU_53(in RAW_PDU_53 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_53(in octetstring stream) return RAW_PDU_53 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_first_for_hexstring() runs on TempComp {
+ const RAW_PDU_53 i := '1234567890'H
+ const octetstring o := '2143658709'O
+
+ if ((enc_RAW_PDU_53(i) == o)and(dec_RAW_PDU_53(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_53(i)= ", enc_RAW_PDU_53(i), "; dec_RAW_PDU_53(o)= ", dec_RAW_PDU_53(o));}
+}
+
+
+
+type hexstring RAW_PDU_54
+with { encode "RAW"; variant "BYTEORDER(last)"};
+external function enc_RAW_PDU_54(in RAW_PDU_54 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_54(in octetstring stream) return RAW_PDU_54 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BYTEORDER_last_for_hexstring() runs on TempComp {
+ const RAW_PDU_54 i := '1234567890'H
+ const octetstring o := '0987654321'O
+
+ if ((enc_RAW_PDU_54(i) == o)and(dec_RAW_PDU_54(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_54(i)= ", enc_RAW_PDU_54(i), "; dec_RAW_PDU_54(o)= ", dec_RAW_PDU_54(o));}
+}
+
+
+type integer RAW_PDU_56
+with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "BITORDERINFIELD(lsb)"};
+
+external function enc_RAW_PDU_56(in RAW_PDU_56 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_56(in octetstring stream) return RAW_PDU_56 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_lsb_for_integer_8() runs on TempComp{
+ const RAW_PDU_56 i := 15
+ const octetstring o := '0F'O
+ if ((enc_RAW_PDU_56(i) == o)and(dec_RAW_PDU_56(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_56(i)= ", enc_RAW_PDU_56(i), "; dec_RAW_PDU_56(o)= ", dec_RAW_PDU_56(o));}
+}
+
+type integer RAW_PDU_57
+with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "BITORDERINFIELD(msb)"};
+
+external function enc_RAW_PDU_57(in RAW_PDU_57 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_57(in octetstring stream) return RAW_PDU_57 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_msb_for_integer_8() runs on TempComp{
+ const RAW_PDU_57 i := 15
+ const octetstring o := 'F0'O
+ if ((enc_RAW_PDU_57(i) == o)and(dec_RAW_PDU_57(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_57(i)= ", enc_RAW_PDU_57(i), "; dec_RAW_PDU_57(o)= ", dec_RAW_PDU_57(o));}
+}
+
+type integer RAW_PDU_58
+with { encode "RAW";
+ variant "FIELDLENGTH(16)" ;
+ variant "BITORDERINFIELD(lsb)"};
+
+external function enc_RAW_PDU_58(in RAW_PDU_58 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_58(in octetstring stream) return RAW_PDU_58 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_lsb_for_integer_16() runs on TempComp{
+ const RAW_PDU_58 i := 4660
+ const octetstring o := '3412'O
+ if ((enc_RAW_PDU_58(i) == o)and(dec_RAW_PDU_58(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_58(i)= ", enc_RAW_PDU_58(i), "; dec_RAW_PDU_58(o)= ", dec_RAW_PDU_58(o));}
+}
+
+type integer RAW_PDU_59
+with { encode "RAW";
+ variant "FIELDLENGTH(16)" ;
+ variant "BITORDERINFIELD(msb)"};
+
+external function enc_RAW_PDU_59(in RAW_PDU_59 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_59(in octetstring stream) return RAW_PDU_59 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_msb_for_integer_16() runs on TempComp{
+ const RAW_PDU_59 i := 4660
+ const octetstring o := '482C'O
+ if ((enc_RAW_PDU_59(i) == o)and(dec_RAW_PDU_59(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_59(i)= ", enc_RAW_PDU_59(i), "; dec_RAW_PDU_59(o)= ", dec_RAW_PDU_59(o));}
+}
+
+type octetstring RAW_PDU_60
+with { encode "RAW";
+ variant "FIELDLENGTH(1)" ;
+ variant "BITORDERINFIELD(lsb)"};
+
+external function enc_RAW_PDU_60(in RAW_PDU_60 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_60(in octetstring stream) return RAW_PDU_60 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_lsb_for_octetstring_1() runs on TempComp{
+ const RAW_PDU_60 i := '0F'O
+ const octetstring o := '0F'O
+ if ((enc_RAW_PDU_60(i) == o)and(dec_RAW_PDU_60(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_60(i)= ", enc_RAW_PDU_60(i), "; dec_RAW_PDU_60(o)= ", dec_RAW_PDU_60(o));}
+}
+
+type octetstring RAW_PDU_61
+with { encode "RAW";
+ variant "FIELDLENGTH(1)" ;
+ variant "BITORDERINFIELD(msb)"};
+
+external function enc_RAW_PDU_61(in RAW_PDU_61 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_61(in octetstring stream) return RAW_PDU_61 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_msb_for_octetstring_1() runs on TempComp{
+ const RAW_PDU_61 i := '0F'O
+ const octetstring o := 'F0'O
+ if ((enc_RAW_PDU_61(i) == o)and(dec_RAW_PDU_61(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_61(i)= ", enc_RAW_PDU_61(i), "; dec_RAW_PDU_61(o)= ", dec_RAW_PDU_61(o));}
+}
+
+type octetstring RAW_PDU_62
+with { encode "RAW";
+ variant "FIELDLENGTH(2)" ;
+ variant "BITORDERINFIELD(lsb)"};
+
+external function enc_RAW_PDU_62(in RAW_PDU_62 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_62(in octetstring stream) return RAW_PDU_62 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_lsb_for_octetstring_2() runs on TempComp{
+ const RAW_PDU_62 i := '1234'O
+ const octetstring o := '1234'O
+ if ((enc_RAW_PDU_62(i) == o)and(dec_RAW_PDU_62(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_62(i)= ", enc_RAW_PDU_62(i), "; dec_RAW_PDU_62(o)= ", dec_RAW_PDU_62(o));}
+}
+
+type octetstring RAW_PDU_63
+with { encode "RAW";
+ variant "FIELDLENGTH(2)" ;
+ variant "BITORDERINFIELD(msb)"};
+
+external function enc_RAW_PDU_63(in RAW_PDU_63 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_63(in octetstring stream) return RAW_PDU_63 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_msb_for_octetstring_2() runs on TempComp{
+ const RAW_PDU_63 i := '1234'O
+ const octetstring o := '2C48'O
+ if ((enc_RAW_PDU_63(i) == o)and(dec_RAW_PDU_63(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_63(i)= ", enc_RAW_PDU_63(i), "; dec_RAW_PDU_63(o)= ", dec_RAW_PDU_63(o));}
+}
+
+type bitstring RAW_PDU_64
+with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "BITORDERINFIELD(lsb)"};
+
+external function enc_RAW_PDU_64(in RAW_PDU_64 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_64(in octetstring stream) return RAW_PDU_64 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_lsb_for_bitstring_8() runs on TempComp{
+ const RAW_PDU_64 i := '00000011'B
+ const octetstring o := '03'O
+ if ((enc_RAW_PDU_64(i) == o)and(dec_RAW_PDU_64(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_64(i)= ", enc_RAW_PDU_64(i), "; dec_RAW_PDU_64(o)= ", dec_RAW_PDU_64(o));}
+}
+
+type bitstring RAW_PDU_65
+with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "BITORDERINFIELD(msb)"};
+
+external function enc_RAW_PDU_65(in RAW_PDU_65 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_65(in octetstring stream) return RAW_PDU_65 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_msb_for_bitstring_8() runs on TempComp{
+ const RAW_PDU_65 i := '00000011'B
+ const octetstring o := 'C0'O
+ if ((enc_RAW_PDU_65(i) == o)and(dec_RAW_PDU_65(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_65(i)= ", enc_RAW_PDU_65(i), "; dec_RAW_PDU_65(o)= ", dec_RAW_PDU_65(o));}
+}
+
+type bitstring RAW_PDU_66
+with { encode "RAW";
+ variant "FIELDLENGTH(16)" ;
+ variant "BITORDERINFIELD(lsb)"};
+
+external function enc_RAW_PDU_66(in RAW_PDU_66 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_66(in octetstring stream) return RAW_PDU_66 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_lsb_for_bitstring_16() runs on TempComp {
+ const RAW_PDU_66 i := '0001111100110001'B
+ const octetstring o := '311F'O
+ if ((enc_RAW_PDU_66(i) == o)and(dec_RAW_PDU_66(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_66(i)= ", enc_RAW_PDU_66(i), "; dec_RAW_PDU_66(o)= ", dec_RAW_PDU_66(o));}
+}
+
+type bitstring RAW_PDU_67
+with { encode "RAW";
+ variant "FIELDLENGTH(16)" ;
+ variant "BITORDERINFIELD(msb)"};
+
+external function enc_RAW_PDU_67(in RAW_PDU_67 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_67(in octetstring stream) return RAW_PDU_67 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_msb_for_bitstring_16() runs on TempComp{
+ const RAW_PDU_67 i := '0001111100110001'B
+ const octetstring o := 'F88C'O
+ if ((enc_RAW_PDU_67(i) == o)and(dec_RAW_PDU_67(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_67(i)= ", enc_RAW_PDU_67(i), "; dec_RAW_PDU_67(o)= ", dec_RAW_PDU_67(o));}
+}
+
+
+
+type enumerated RAW_PDU_68
+ { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
+ tenth }
+with { encode "RAW";
+ variant "FIELDLENGTH(4)" ;
+ variant "BITORDERINFIELD (lsb) "};
+
+
+
+external function enc_RAW_PDU_68(in RAW_PDU_68 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_68(in octetstring stream) return RAW_PDU_68 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_lsb_for_enumerated_4() runs on TempComp{
+ const RAW_PDU_68 i := first
+ const octetstring o := '01'O
+ if ((enc_RAW_PDU_68(i) == o)and(dec_RAW_PDU_68(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_68(i)= ", enc_RAW_PDU_68(i), "; dec_RAW_PDU_68(o)= ", dec_RAW_PDU_68(o));}
+}
+
+type enumerated RAW_PDU_69
+ { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
+ tenth }
+with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "BITORDERINFIELD (msb) "};
+
+external function enc_RAW_PDU_69(in RAW_PDU_69 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_69(in octetstring stream) return RAW_PDU_69 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_msb_for_enumerated_8() runs on TempComp{
+ const RAW_PDU_69 i := first;
+ const octetstring o := '80'O;
+ if ((enc_RAW_PDU_69(i) == o)and(dec_RAW_PDU_69(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_69(i)= ", enc_RAW_PDU_69(i), "; dec_RAW_PDU_69(o)= ", dec_RAW_PDU_69(o));}
+}
+
+
+type hexstring RAW_PDU_70
+with { encode "RAW"; variant "BITORDERINFIELD(lsb)"};
+
+
+external function enc_RAW_PDU_70(in RAW_PDU_70 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_70(in octetstring stream) return RAW_PDU_70 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_lsb_for_hexstring() runs on TempComp{
+ const RAW_PDU_70 i := '1234'H
+ const octetstring o := '2143'O
+ if ((enc_RAW_PDU_70(i) == o)and(dec_RAW_PDU_70(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_70(i)= ", enc_RAW_PDU_70(i), "; dec_RAW_PDU_70(o)= ", dec_RAW_PDU_70(o));}
+}
+
+type hexstring RAW_PDU_71
+with { encode "RAW"; variant "BITORDERINFIELD(msb)"};
+
+
+
+external function enc_RAW_PDU_71(in RAW_PDU_71 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_71(in octetstring stream) return RAW_PDU_71 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINFIELD_msb_for_hexstring() runs on TempComp {
+ const RAW_PDU_71 i := '1234'H
+ const octetstring o := 'C284'O
+ if ((enc_RAW_PDU_71(i) == o)and(dec_RAW_PDU_71(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_71(i)= ", enc_RAW_PDU_71(i), "; dec_RAW_PDU_71(o)= ", dec_RAW_PDU_71(o));}
+}
+
+//Testing BITORDERINOCTET Attribute:
+
+type integer RAW_PDU_72
+with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "BITORDERINOCTET(lsb)"};
+
+external function enc_RAW_PDU_72(in RAW_PDU_72 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_72(in octetstring stream) return RAW_PDU_72 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_lsb_for_integer_8() runs on TempComp{
+ const RAW_PDU_72 i := 15;
+ const octetstring o := '0F'O;
+ if ((enc_RAW_PDU_72(i) == o)and(dec_RAW_PDU_72(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_72(i)= ", enc_RAW_PDU_72(i), "; dec_RAW_PDU_72(o)= ", dec_RAW_PDU_72(o));}
+}
+
+type integer RAW_PDU_73
+with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "BITORDERINOCTET(msb)"};
+
+external function enc_RAW_PDU_73(in RAW_PDU_73 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_73(in octetstring stream) return RAW_PDU_73 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_msb_for_integer_8() runs on TempComp{
+ const RAW_PDU_73 i := 15
+ const octetstring o := 'F0'O
+ if ((enc_RAW_PDU_73(i) == o)and(dec_RAW_PDU_73(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_73(i)= ", enc_RAW_PDU_73(i), "; dec_RAW_PDU_73(o)= ", dec_RAW_PDU_73(o));}
+}
+
+type integer RAW_PDU_74
+with { encode "RAW";
+ variant "FIELDLENGTH(16)" ;
+ variant "BITORDERINOCTET(lsb)"};
+
+external function enc_RAW_PDU_74(in RAW_PDU_74 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_74(in octetstring stream) return RAW_PDU_74 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_lsb_for_integer_16() runs on TempComp{
+ const RAW_PDU_74 i := 4660
+ const octetstring o := '3412'O
+ if ((enc_RAW_PDU_74(i) == o)and(dec_RAW_PDU_74(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_74(i)= ", enc_RAW_PDU_74(i), "; dec_RAW_PDU_74(o)= ", dec_RAW_PDU_74(o));}
+}
+
+type integer RAW_PDU_75
+with { encode "RAW";
+ variant "FIELDLENGTH(16)" ;
+ variant "BITORDERINOCTET(msb)"};
+
+external function enc_RAW_PDU_75(in RAW_PDU_75 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_75(in octetstring stream) return RAW_PDU_75 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_msb_for_integer_16() runs on TempComp{
+ const RAW_PDU_75 i := 4660
+ const octetstring o := '2C48'O
+ if ((enc_RAW_PDU_75(i) == o)and(dec_RAW_PDU_75(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_75(i)= ", enc_RAW_PDU_75(i), "; dec_RAW_PDU_75(o)= ", dec_RAW_PDU_75(o));}
+}
+
+type octetstring RAW_PDU_76
+with { encode "RAW";
+ variant "FIELDLENGTH(1)" ;
+ variant "BITORDERINOCTET(lsb)"
+ };
+
+external function enc_RAW_PDU_76(in RAW_PDU_76 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_76(in octetstring stream) return RAW_PDU_76 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_lsb_for_octetstring_1() runs on TempComp{
+ const RAW_PDU_76 i := '0F'O
+ const octetstring o := '0F'O
+ if ((enc_RAW_PDU_76(i) == o)and(dec_RAW_PDU_76(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_76(i)= ", enc_RAW_PDU_76(i), "; dec_RAW_PDU_76(o)= ", dec_RAW_PDU_76(o));}
+}
+
+type octetstring RAW_PDU_77
+with { encode "RAW";
+ variant "FIELDLENGTH(1)" ;
+ variant "BITORDERINOCTET(msb)"
+ };
+
+external function enc_RAW_PDU_77(in RAW_PDU_77 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_77(in octetstring stream) return RAW_PDU_77 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_msb_for_octetstring_1() runs on TempComp{
+ const RAW_PDU_77 i := '0F'O
+ const octetstring o := 'F0'O
+ if ((enc_RAW_PDU_77(i) == o)and(dec_RAW_PDU_77(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_77(i)= ", enc_RAW_PDU_77(i), "; dec_RAW_PDU_77(o)= ", dec_RAW_PDU_77(o));}
+}
+
+type octetstring RAW_PDU_78
+with { encode "RAW";
+ variant "FIELDLENGTH(2)" ;
+ variant "BITORDERINOCTET(lsb)"
+ };
+
+external function enc_RAW_PDU_78(in RAW_PDU_78 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_78(in octetstring stream) return RAW_PDU_78 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_lsb_for_octetstring_2() runs on TempComp{
+ const RAW_PDU_78 i := '1234'O
+ const octetstring o := '1234'O
+ if ((enc_RAW_PDU_78(i) == o)and(dec_RAW_PDU_78(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_78(i)= ", enc_RAW_PDU_78(i), "; dec_RAW_PDU_78(o)= ", dec_RAW_PDU_78(o));}
+}
+
+type octetstring RAW_PDU_79
+with { encode "RAW";
+ variant "FIELDLENGTH(2)" ;
+ variant "BITORDERINOCTET(msb)"
+ };
+
+external function enc_RAW_PDU_79(in RAW_PDU_79 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_79(in octetstring stream) return RAW_PDU_79 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_msb_for_octetstring_2() runs on TempComp{
+ const RAW_PDU_79 i := '1234'O
+ const octetstring o := '482C'O
+ if ((enc_RAW_PDU_79(i) == o)and(dec_RAW_PDU_79(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_79(i)= ", enc_RAW_PDU_79(i), "; dec_RAW_PDU_79(o)= ", dec_RAW_PDU_79(o));}
+}
+
+type bitstring RAW_PDU_80
+with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "BITORDERINOCTET(lsb)"
+};
+external function enc_RAW_PDU_80(in RAW_PDU_80 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_80(in octetstring stream) return RAW_PDU_80 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_lsb_for_bitstring_8() runs on TempComp{
+ const RAW_PDU_80 i := '00000011'B
+ const octetstring o := '03'O
+ if ((enc_RAW_PDU_80(i) == o)and(dec_RAW_PDU_80(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_80(i)= ", enc_RAW_PDU_80(i), "; dec_RAW_PDU_80(o)= ", dec_RAW_PDU_80(o));}
+}
+
+type bitstring RAW_PDU_81
+with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "BITORDERINOCTET(msb)"
+};
+external function enc_RAW_PDU_81(in RAW_PDU_81 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_81(in octetstring stream) return RAW_PDU_81 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_msb_for_bitstring_8() runs on TempComp{
+ const RAW_PDU_81 i := '00000011'B
+ const octetstring o := 'C0'O
+ if ((enc_RAW_PDU_81(i) == o)and(dec_RAW_PDU_81(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_81(i)= ", enc_RAW_PDU_81(i), "; dec_RAW_PDU_81(o)= ", dec_RAW_PDU_81(o));}
+}
+
+type bitstring RAW_PDU_82
+with { encode "RAW";
+ variant "FIELDLENGTH(16)" ;
+ variant "BITORDERINOCTET(lsb)"
+};
+external function enc_RAW_PDU_82(in RAW_PDU_82 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_82(in octetstring stream) return RAW_PDU_82 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_lsb_for_bitstring_16() runs on TempComp{
+ const RAW_PDU_82 i := '0001111100110001'B
+ const octetstring o := '311F'O
+ if ((enc_RAW_PDU_82(i) == o)and(dec_RAW_PDU_82(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_82(i)= ", enc_RAW_PDU_82(i), "; dec_RAW_PDU_82(o)= ", dec_RAW_PDU_82(o));}
+}
+
+type bitstring RAW_PDU_83
+with { encode "RAW";
+ variant "FIELDLENGTH(16)" ;
+ variant "BITORDERINOCTET(msb)"
+};
+external function enc_RAW_PDU_83(in RAW_PDU_83 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_83(in octetstring stream) return RAW_PDU_83 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_msb_for_bitstring_16() runs on TempComp{
+ const RAW_PDU_83 i := '0001111100110001'B
+ const octetstring o := '8CF8'O
+ if ((enc_RAW_PDU_83(i) == o)and(dec_RAW_PDU_83(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_83(i)= ", enc_RAW_PDU_83(i), "; dec_RAW_PDU_83(o)= ", dec_RAW_PDU_83(o));}
+}
+
+type enumerated RAW_PDU_84
+ { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
+ tenth }
+with { encode "RAW";
+ variant "FIELDLENGTH(4)" ;
+ variant "BITORDERINOCTET (lsb) "
+ };
+
+external function enc_RAW_PDU_84(in RAW_PDU_84 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_84(in octetstring stream) return RAW_PDU_84 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_lsb_for_enumerated() runs on TempComp{
+ const RAW_PDU_84 i := first
+ const octetstring o := '01'O
+ if ((enc_RAW_PDU_84(i) == o)and(dec_RAW_PDU_84(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_84(i)= ", enc_RAW_PDU_84(i), "; dec_RAW_PDU_84(o)= ", dec_RAW_PDU_84(o));}
+}
+
+type enumerated RAW_PDU_85
+ { zero, first, second, third, fourth, fifth, sixth , seventh, eight, nineth,
+ tenth }
+with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "BITORDERINOCTET (msb) "
+ };
+
+external function enc_RAW_PDU_85(in RAW_PDU_85 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_85(in octetstring stream) return RAW_PDU_85 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_msb_for_enumerated() runs on TempComp{
+ const RAW_PDU_85 i := first
+ const octetstring o := '80'O
+
+ if ((enc_RAW_PDU_85(i) == o)and(dec_RAW_PDU_85(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_85(i)= ", enc_RAW_PDU_85(i), "; dec_RAW_PDU_85(o)= ", dec_RAW_PDU_85(o));}
+}
+
+type hexstring RAW_PDU_86
+with { encode "RAW"; variant "BITORDERINOCTET(lsb)"};
+
+external function enc_RAW_PDU_86(in RAW_PDU_86 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_86(in octetstring stream) return RAW_PDU_86 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_lsb_for_hexstring() runs on TempComp{
+ const RAW_PDU_86 i := '1234'H
+ const octetstring o := '2143'O
+ if ((enc_RAW_PDU_86(i) == o)and(dec_RAW_PDU_86(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_86(i)= ", enc_RAW_PDU_86(i), "; dec_RAW_PDU_86(o)= ", dec_RAW_PDU_86(o));}
+}
+
+type hexstring RAW_PDU_87
+with { encode "RAW"; variant "BITORDERINOCTET(msb)"};
+
+external function enc_RAW_PDU_87(in RAW_PDU_87 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_87(in octetstring stream) return RAW_PDU_87 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_BITORDERINOCTET_msb_for_hexstring() runs on TempComp{
+ const RAW_PDU_87 i := '1234'H
+ const octetstring o := '84C2'O
+ if ((enc_RAW_PDU_87(i) == o)and(dec_RAW_PDU_87(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_87(i)= ", enc_RAW_PDU_87(i), "; dec_RAW_PDU_87(o)= ", dec_RAW_PDU_87(o));}
+}
+
+type integer RAW_PDU_88
+with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "COMP( nosign ) "
+ };
+external function enc_RAW_PDU_88(in RAW_PDU_88 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_88(in octetstring stream) return RAW_PDU_88 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_COMP_nosign_for_positive_integer_8() runs on TempComp{
+ const RAW_PDU_88 i := 2
+ const octetstring o := '02'O
+ if ((enc_RAW_PDU_88(i) == o)and(dec_RAW_PDU_88(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_88(i)= ", enc_RAW_PDU_88(i), "; dec_RAW_PDU_88(o)= ", dec_RAW_PDU_88(o));}
+}
+
+type integer RAW_PDU_89
+with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "COMP( signbit ) "
+ };
+external function enc_RAW_PDU_89(in RAW_PDU_89 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_89(in octetstring stream) return RAW_PDU_89 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_COMP_signbit_for_positive_integer_8() runs on TempComp{
+ const RAW_PDU_89 i := 2
+ const octetstring o := '02'O
+ if ((enc_RAW_PDU_89(i) == o)and(dec_RAW_PDU_89(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_89(i)= ", enc_RAW_PDU_89(i), "; dec_RAW_PDU_89(o)= ", dec_RAW_PDU_89(o));}
+}
+
+testcase TC_COMP_signbit_for_negative_integer_8() runs on TempComp{
+ const RAW_PDU_89 i := -2
+ const octetstring o := '82'O
+ if ((enc_RAW_PDU_89(i) == o)and(dec_RAW_PDU_89(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_89(i)= ", enc_RAW_PDU_89(i), "; dec_RAW_PDU_89(o)= ", dec_RAW_PDU_89(o));}
+}
+
+type integer RAW_PDU_90
+with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "COMP( 2scompl ) "
+};
+
+external function enc_RAW_PDU_90(in RAW_PDU_90 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_90(in octetstring stream) return RAW_PDU_90 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_COMP_2scompl_for_positive_integer_8() runs on TempComp{
+ const RAW_PDU_90 i := 2
+ const octetstring o := '02'O
+ if ((enc_RAW_PDU_90(i) == o)and(dec_RAW_PDU_90(o) == i )) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase TC_COMP_2scompl_for_negative_integer_8() runs on TempComp{
+ const RAW_PDU_90 i := -2
+ const octetstring o := 'FE'O
+ if ((enc_RAW_PDU_90(i) == o)and(dec_RAW_PDU_90(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_90(i)= ", enc_RAW_PDU_90(i), "; dec_RAW_PDU_90(o)= ", dec_RAW_PDU_90(o));}
+}
+
+// PADDING for integer
+
+group RAW_group1{
+
+type record RAW_PDU_91
+{ integer int1 ,
+ integer int2 ,
+ integer int3 ,
+ integer int4 }
+ with { variant (int3) "FIELDLENGTH (4)" ;
+ variant (int1) "PADDING( yes ) " ;
+ variant (int2) "FIELDLENGTH (4)" ;
+ variant (int2) "PADDING( yes ) " ;
+ variant (int3) "FIELDLENGTH (4)" ;
+ variant (int3) "PADDING( no ) " ;
+ variant (int4) "FIELDLENGTH (4)" ;
+ variant (int4) "PADDING( no ) " ; }
+} with {encode "RAW" };
+
+external function enc_RAW_PDU_91(in RAW_PDU_91 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_91(in octetstring stream) return RAW_PDU_91 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PADDING_for_integer() runs on TempComp{
+
+ const RAW_PDU_91
+ i := {
+ int1 := 1 ,
+ int2 := 2 ,
+ int3 := 3 ,
+ int4 := 4 }
+
+ const octetstring o := '010243'O
+
+ if ((enc_RAW_PDU_91(i) == o)and(dec_RAW_PDU_91(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_91(i)= ", enc_RAW_PDU_91(i), "; dec_RAW_PDU_91(o)= ", dec_RAW_PDU_91(o));}
+}
+
+// PADDING for bitstring
+group RAW_group2{
+
+type record RAW_PDU_92
+{ bitstring bit1 ,
+ bitstring bit2 ,
+ bitstring bit3 ,
+ bitstring bit4 }
+ with { variant (bit1) "FIELDLENGTH(4)" ;
+ variant (bit1) "PADDING( yes ) " ;
+ variant (bit2) "FIELDLENGTH(4)" ;
+ variant (bit2) "PADDING( yes ) " ;
+ variant (bit3) "FIELDLENGTH(4)" ;
+ variant (bit3) "PADDING( no ) " ;
+ variant (bit4) "FIELDLENGTH(4)" ;
+ variant (bit4) "PADDING( no ) " ;
+ };
+} with {encode "RAW"}
+
+
+external function enc_RAW_PDU_92(in RAW_PDU_92 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_92(in octetstring stream) return RAW_PDU_92 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PADDING_for_bitstring() runs on TempComp{
+
+ const RAW_PDU_92
+ i := { bit1 := '0001'B ,
+ bit2 := '0010'B ,
+ bit3 := '0011'B ,
+ bit4 := '0100'B }
+ const octetstring o := '010243'O;
+
+ if ((enc_RAW_PDU_92(i) == o)and(dec_RAW_PDU_92(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_92(i)= ", enc_RAW_PDU_92(i), "; dec_RAW_PDU_92(o)= ", dec_RAW_PDU_92(o));}
+}
+
+// PADDING for enumerated
+
+group RAW_group3{
+
+type enumerated enumerated1
+{ zero, first, second, third, fourth, fifth }
+
+type enumerated enumerated2
+{ tenth, eleventh, twelfth, thirteenth, fourthteenth, fifteenth }
+
+type enumerated enumerated3
+{ twenty, twentyfirst, twentysecond, twentythird, twentyfourth, twentyfifth }
+
+type enumerated enumerated4
+{ thirty, thirtyfirst, thirtysecond, thirtythird, thirtyfourth, thirtyfifth }
+
+
+type record RAW_PDU_93
+{ enumerated1 enum1 ,
+ enumerated2 enum2 ,
+ enumerated3 enum3 ,
+ enumerated4 enum4 }
+ with { variant (enum1) "FIELDLENGTH(4)" ;
+ variant (enum1) "PADDING( yes ) " ;
+ variant (enum2) "FIELDLENGTH(4)" ;
+ variant (enum2) "PADDING( yes ) " ;
+ variant (enum3) "FIELDLENGTH(4)" ;
+ variant (enum3) "PADDING( no ) " ;
+ variant (enum4) "FIELDLENGTH(4)" ;
+ variant (enum4) "PADDING( no ) " ;
+ };
+} with {encode "RAW" };
+
+external function enc_RAW_PDU_93(in RAW_PDU_93 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_93(in octetstring stream) return RAW_PDU_93 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PADDING_for_enumerated() runs on TempComp{
+ const RAW_PDU_93
+ i := { enum1 := first ,
+ enum2 := twelfth ,
+ enum3 := twentythird ,
+ enum4 := thirtyfourth }
+
+ const octetstring o := '010243'O
+
+ if ((enc_RAW_PDU_93(i) == o)and(dec_RAW_PDU_93(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_93(i)= ", enc_RAW_PDU_93(i), "; dec_RAW_PDU_93(o)= ", dec_RAW_PDU_93(o));}
+}
+
+// PADDING for hexstring
+
+group RAW_group4{
+
+type record RAW_PDU_94
+{ hexstring hex1 ,
+ hexstring hex2 ,
+ hexstring hex3 ,
+ hexstring hex4 }
+ with { encode "RAW";
+ variant (hex1) "FIELDLENGTH(1)" ;
+ variant (hex1) "PADDING( yes ) " ;
+ variant (hex2) "FIELDLENGTH(1)" ;
+ variant (hex2) "PADDING( yes ) " ;
+ variant (hex3) "FIELDLENGTH(1)" ;
+ variant (hex3) "PADDING( no ) " ;
+ variant (hex4) "FIELDLENGTH(1)" ;
+ variant (hex4) "PADDING( no ) " ;
+ };
+} with {encode "RAW" }
+
+external function enc_RAW_PDU_94(in RAW_PDU_94 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_94(in octetstring stream) return RAW_PDU_94 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PADDING_for_hexstring() runs on TempComp{
+ const RAW_PDU_94
+ i := { hex1 := '1'H ,
+ hex2 := '2'H ,
+ hex3 := '3'H ,
+ hex4 := '4'H }
+
+ const octetstring o := '010243'O
+
+ if ((enc_RAW_PDU_94(i) == o)and(dec_RAW_PDU_94(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_94(i)= ", enc_RAW_PDU_94(i), "; dec_RAW_PDU_94(o)= ", dec_RAW_PDU_94(o));}
+}
+
+// PREPADDING(yes) for bitstring
+
+type bitstring RAW_PDU_95 length (3)
+with {encode "RAW"; variant "PREPADDING(yes)"}
+
+external function enc_RAW_PDU_95(in RAW_PDU_95 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_95(in octetstring stream) return RAW_PDU_95 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PREPADDING_yes_for_bitstring() runs on TempComp{
+ const RAW_PDU_95 i := '101'B
+ const octetstring o := '05'O
+
+ if ((enc_RAW_PDU_95(i) == o)and(dec_RAW_PDU_95(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_95(i)= ", enc_RAW_PDU_95(i), "; dec_RAW_PDU_95(o)= ", dec_RAW_PDU_95(o));}
+}
+
+// PREPADDING(yes) for hexstring
+
+type hexstring RAW_PDU_96 length (1)
+with {encode "RAW"; variant "PREPADDING(yes)"}
+
+external function enc_RAW_PDU_96(in RAW_PDU_96 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_96(in octetstring stream) return RAW_PDU_96 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PREPADDING_yes_for_hexstring() runs on TempComp{
+ const RAW_PDU_96 i := 'F'H
+ const octetstring o := '0F'O
+
+ if ((enc_RAW_PDU_96(i) == o)and(dec_RAW_PDU_96(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_96(i)= ", enc_RAW_PDU_96(i), "; dec_RAW_PDU_96(o)= ", dec_RAW_PDU_96(o));}
+}
+
+// PREPADDING(word16) for octetstring
+
+type octetstring otype1
+with {encode "RAW"; variant "PREPADDING(word16)"}
+type hexstring htype1 length (3)
+type record RAW_PDU_97 { htype1 h, otype1 o}
+with {encode "RAW"; variant ""}
+
+external function enc_RAW_PDU_97(in RAW_PDU_97 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_97(in octetstring stream) return RAW_PDU_97 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PREPADDING_word16_for_octetstring() runs on TempComp{
+ const RAW_PDU_97 i := {'AAA'H,'FF'O}
+ const octetstring o := 'AA0AFF'O
+
+ if ((enc_RAW_PDU_97(i) == o)and(dec_RAW_PDU_97(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_97(i)= ", enc_RAW_PDU_97(i), "; dec_RAW_PDU_97(o)= ", dec_RAW_PDU_97(o));}
+}
+
+// PREPADDING(word16) for record of
+
+type integer itype1
+with {encode "RAW"; variant "FIELDLENGTH(3)"}
+type record length (1) of itype1 rtype1
+with {encode "RAW"; variant "PREPADDING(word16)"}
+
+type record RAW_PDU_98 {itype1 r1, rtype1 r2}
+with {encode "RAW"; variant ""}
+
+external function enc_RAW_PDU_98(in RAW_PDU_98 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_98(in octetstring stream) return RAW_PDU_98 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PREPADDING_word16_for_record_of() runs on TempComp{
+ const RAW_PDU_98 i := {4,{7}}
+ const octetstring o := '040007'O
+
+ if ((enc_RAW_PDU_98(i) == o)and(dec_RAW_PDU_98(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_98(i)= ", enc_RAW_PDU_98(i), "; dec_RAW_PDU_98(o)= ", dec_RAW_PDU_98(o));}
+}
+
+// PREPADDING(dword32) for set of
+type bitstring BIT3 length (3)
+type record length (2) of BIT3 rtype2
+with {encode "RAW"; variant "PREPADDING(dword32)"}
+
+type record RAW_PDU_99 {BIT3 r1, rtype2 r2}
+with {encode "RAW"; variant ""}
+
+external function enc_RAW_PDU_99(in RAW_PDU_99 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_99(in octetstring stream) return RAW_PDU_99 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PREPADDING_dword32_for_set_of() runs on TempComp{
+ const RAW_PDU_99 i := {'100'B,{'111'B, '101'B}}
+ const octetstring o := '040000002F'O
+
+ if ((enc_RAW_PDU_99(i) == o)and(dec_RAW_PDU_99(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_99(i)= ", enc_RAW_PDU_99(i), "; dec_RAW_PDU_99(o)= ", dec_RAW_PDU_99(o));}
+}
+
+// PREPADDING(dword32) for record
+
+//type bitstring BIT3 length (3)
+
+type record stype1 {BIT3 s1, BIT3 s2}
+with {encode "RAW"; variant "PREPADDING(dword32)"}
+
+type record RAW_PDU_100 {stype1 r1, stype1 r2, stype1 r3}
+with {encode "RAW"; variant ""}
+
+external function enc_RAW_PDU_100(in RAW_PDU_100 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_100(in octetstring stream) return RAW_PDU_100 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PREPADDING_dword32_for_record() runs on TempComp{
+ const RAW_PDU_100 i := {{'111'B,'111'B},{'110'B,'000'B},{'111'B,'111'B}}
+ const octetstring o := '3F000000060000003F'O
+
+ if ((enc_RAW_PDU_100(i) == o)and(dec_RAW_PDU_100(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_100(i)= ", enc_RAW_PDU_100(i), "; dec_RAW_PDU_100(o)= ", dec_RAW_PDU_100(o));}
+}
+
+// PREPADDING(word16) for set
+
+//type bitstring BIT3 length (3)
+
+type set stype2 {BIT3 s1}
+with {encode "RAW"; variant "PREPADDING(word16)"}
+
+type record RAW_PDU_101 {stype2 r1, stype2 r2, stype2 r3}
+with {encode "RAW"; variant ""}
+
+external function enc_RAW_PDU_101(in RAW_PDU_101 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_101(in octetstring stream) return RAW_PDU_101 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PREPADDING_word16_for_set() runs on TempComp{
+ const RAW_PDU_101 i := {{s1:='111'B},{s1:='110'B},{s1:='111'B}}
+ const octetstring o := '0700060007'O
+
+ if ((enc_RAW_PDU_101(i) == o)and(dec_RAW_PDU_101(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_101(i)= ", enc_RAW_PDU_101(i), "; dec_RAW_PDU_101(o)= ", dec_RAW_PDU_101(o));}
+}
+
+// PREPADDING(word16) for union
+
+type hexstring HEX1 length (1)
+
+type union utype1 {BIT3 u1, HEX1 u2}
+with {encode "RAW"; variant "PREPADDING(word16)"}
+
+type record RAW_PDU_102 {utype1 r1, utype1 r2, utype1 r3}
+with {encode "RAW"; variant ""}
+
+external function enc_RAW_PDU_102(in RAW_PDU_102 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_102(in octetstring stream) return RAW_PDU_102 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PREPADDING_word16_for_union() runs on TempComp{
+ const RAW_PDU_102 i := {{u1:='111'B},{u1:='010'B},{u1:='111'B}}
+ const octetstring o := '0700020007'O
+
+ if ((enc_RAW_PDU_102(i) == o)and(dec_RAW_PDU_102(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_102(i)= ", enc_RAW_PDU_102(i), "; dec_RAW_PDU_102(o)= ", dec_RAW_PDU_102(o));}
+}
+
+// PADDING_PATTERN for record of
+
+type integer itype2
+with {encode "RAW"; variant "FIELDLENGTH(3)"}
+type record length (1) of itype2 rtype
+with {encode "RAW"; variant "PREPADDING(yes), PADDING_PATTERN('1'B)"}
+
+type record RAW_PDU_103 {itype2 r1, rtype r2}
+with {encode "RAW"; variant ""}
+
+external function enc_RAW_PDU_103(in RAW_PDU_103 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_103(in octetstring stream) return RAW_PDU_103 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PADDING_PATTERN_for_record_of() runs on TempComp{
+ const RAW_PDU_103 i := {4,{7}};
+ const octetstring o := 'FC07'O;
+
+ if ((enc_RAW_PDU_103(i) == o)and(dec_RAW_PDU_103(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_103(i)= ", enc_RAW_PDU_103(i), "; dec_RAW_PDU_103(o)= ", dec_RAW_PDU_103(o));}
+}
+
+// PADDING_PATTERN for set of:
+type set length (2) of BIT3 rtype3
+with {encode "RAW"; variant "PREPADDING(yes), PADDING_PATTERN('10000'B)"}
+
+type record RAW_PDU_104 {BIT3 r1, rtype3 r2}
+with {encode "RAW"; variant ""}
+
+external function enc_RAW_PDU_104(in RAW_PDU_104 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_104(in octetstring stream) return RAW_PDU_104 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PADDING_PATTERN_for_set_of() runs on TempComp{
+ const RAW_PDU_104 i := {'100'B,{'111'B, '101'B}}
+ const octetstring o := '842F'O
+
+ if ((enc_RAW_PDU_104(i) == o)and(dec_RAW_PDU_104(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_104(i)= ", enc_RAW_PDU_104(i), "; dec_RAW_PDU_104(o)= ", dec_RAW_PDU_104(o));}
+}
+
+// PADDING_PATTERN for record:
+
+type bitstring BIT9 length (9)
+
+type record stype3 {BIT9 s1, BIT9 s2}
+with {encode "RAW"; variant "PREPADDING(40), PADDING_PATTERN('100000'B)"}
+
+type record RAW_PDU_105 {stype3 r1, stype3 r2, stype3 r3}
+with {encode "RAW"; variant ""}
+
+external function enc_RAW_PDU_105(in RAW_PDU_105 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_105(in octetstring stream) return RAW_PDU_105 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PADDING_PATTERN_for_record() runs on TempComp{
+ const RAW_PDU_105 i := {{'111000111'B,'111000111'B},{'111111111'B,'111111111'B},{'111000111'B,'111000111'B}};
+ const octetstring o := 'C78F832008FFFF832008C78F03'O ;
+
+ if ((enc_RAW_PDU_105(i) == o)and(dec_RAW_PDU_105(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_105(i)= ", enc_RAW_PDU_105(i), "; dec_RAW_PDU_105(o)= ", dec_RAW_PDU_105(o));}
+}
+
+//PADDING_PATTERN for set
+type hexstring HEX3 length (3)
+type set stype4 {HEX3 s1}
+with {encode "RAW"; variant "PREPADDING(15), PADDING_PATTERN('10001'B)"}
+
+type record RAW_PDU_106 {stype4 r1, stype4 r2, stype4 r3}
+with {encode "RAW"; variant ""}
+
+external function enc_RAW_PDU_106(in RAW_PDU_106 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_106(in octetstring stream) return RAW_PDU_106 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PADDING_PATTERN_for_set() runs on TempComp{
+ const RAW_PDU_106 i := {{s1:='FFF'H},{s1:='FFF'H},{s1:='FFF'H}}
+ const octetstring o := 'FF9FFFCFFF03'O
+
+ if ((enc_RAW_PDU_106(i) == o)and(dec_RAW_PDU_106(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_106(i)= ", enc_RAW_PDU_106(i), "; dec_RAW_PDU_106(o)= ", dec_RAW_PDU_106(o));}
+}
+
+// PADDING_PATTERN for union:
+type octetstring OCT2 length (2)
+
+type union utype2 {OCT2 u1, hexstring u2}
+with {encode "RAW"; variant "PREPADDING(256),PADDING_PATTERN('11001'B)"}
+
+type record RAW_PDU_107 {utype2 r1, utype2 r2, utype2 r3}
+with {encode "RAW"; variant ""}
+
+external function enc_RAW_PDU_107(in RAW_PDU_107 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_107(in octetstring stream) return RAW_PDU_107 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PADDING_PATTERN_for_union() runs on TempComp{
+ const RAW_PDU_107 i := {{u1:='AABB'O},{u1:='CCDD'O},{u1:='EEFF'O}}
+ const octetstring o := 'AABB39E79C73CE39E79C73CE39E79C73CE39E79C73CE39E79C73CE39E79C73CECCDD39E79C73CE39E79C73CE39E79C73CE39E79C73CE39E79C73CE39E79C73CEEEFF'O
+
+ if ((enc_RAW_PDU_107(i) == o)and(dec_RAW_PDU_107(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_107(i)= ", enc_RAW_PDU_107(i), "; dec_RAW_PDU_107(o)= ", dec_RAW_PDU_107(o));}
+}
+
+// PADDALL with PADDING Attribute - record
+type bitstring BIT1 length (1)
+
+type record stype5 {BIT1 s1, BIT1 s2}
+with {encode "RAW"; variant "PADDING(yes), PADDALL"}
+
+type record RAW_PDU_108 {stype5 r1, stype5 r2, stype5 r3}
+with {encode "RAW"; variant ""}
+
+external function enc_RAW_PDU_108(in RAW_PDU_108 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_108(in octetstring stream) return RAW_PDU_108 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PADDALL_with_PADDING_Attribute_record() runs on TempComp{
+ const RAW_PDU_108 i := {{'1'B,'1'B},{'1'B,'1'B},{'1'B,'1'B}};
+ const octetstring o := '010101010101'O;
+
+ if ((enc_RAW_PDU_108(i) == o)and(dec_RAW_PDU_108(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_108(i)= ", enc_RAW_PDU_108(i), "; dec_RAW_PDU_108(o)= ", dec_RAW_PDU_108(o));}
+}
+
+//PADDALL with PADDING Attribute - set
+
+//type bitstring BIT3 length (3)
+
+type set stype6 {BIT3 s1, BIT3 s2}
+with {encode "RAW"; variant "PADDING(4), PADDALL"}
+
+type set RAW_PDU_109 {stype6 r1, stype6 r2}
+with {encode "RAW"; variant "PADDING(dword32), PADDALL"}
+
+external function enc_RAW_PDU_109(in RAW_PDU_109 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_109(in octetstring stream) return RAW_PDU_109 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PADDALL_with_PADDING_Attribute_set() runs on TempComp{
+ const RAW_PDU_109 i := {r1:={s1:='111'B,s2:='101'B},r2:={s1:='111'B,s2:='101'B}}
+ const octetstring o := '57570000'O;
+
+ if ((enc_RAW_PDU_109(i) == o)and(dec_RAW_PDU_109(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_109(i)= ", enc_RAW_PDU_109(i), "; dec_RAW_PDU_109(o)= ", dec_RAW_PDU_109(o));}
+}
+
+ // PADDALL with PREPADDING Attribute - record
+
+//type hexstring HEX1 length (1)
+
+type record stype7 {HEX1 s1, HEX1 s2}
+
+type record RAW_PDU_110 {stype7 r1, stype7 r2, stype7 r3}
+with {encode "RAW"; variant "PREPADDING(12), PADDALL"}
+
+external function enc_RAW_PDU_110(in RAW_PDU_110 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_110(in octetstring stream) return RAW_PDU_110 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PADDALL_with_PREPADDING_Attribute_record() runs on TempComp{
+ const RAW_PDU_110 i := {{'A'H,'B'H},{'A'H,'B'H},{'A'H,'B'H}}
+ const octetstring o := 'BAA00BBA'O
+
+ if ((enc_RAW_PDU_110(i) == o)and(dec_RAW_PDU_110(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_110(i)= ", enc_RAW_PDU_110(i), "; dec_RAW_PDU_110(o)= ", dec_RAW_PDU_110(o));}
+}
+
+// PADDALL with PREPADDING Attribute - set
+//type hexstring HEX1 length (1)
+
+type set stype8 {HEX1 s1, HEX1 s2, HEX1 s3}
+with {encode "RAW"; variant "PREPADDING(12), PADDALL"}
+
+type set RAW_PDU_111 {stype8 r1, stype8 r2}
+with {encode "RAW"; variant "PREPADDING(36), PADDALL, PADDING_PATTERN('1111'B)"}
+
+external function enc_RAW_PDU_111(in RAW_PDU_111 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_111(in octetstring stream) return RAW_PDU_111 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PADDALL_with_PREPADDING_Attribute_set() runs on TempComp{
+ const RAW_PDU_111 i := { r1:={s1:='A'H,s2:='B'H,s3:='C'H},
+ r2:={s1:='A'H,s2:='B'H,s3:='C'H}}
+ const octetstring o := '0AB000FCAF000BC0'O
+
+ if ((enc_RAW_PDU_111(i) == o)and(dec_RAW_PDU_111(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_111(i)= ", enc_RAW_PDU_111(i), "; dec_RAW_PDU_111(o)= ", dec_RAW_PDU_111(o));}
+}
+
+//==== Testing PTROFFSET Attribute ===
+
+// PTROFFSET is set to default base
+type bitstring BIT4 length (4)
+//type hexstring HEX1 length (1)
+type octetstring OCT3 length (3)
+
+group RAW_group5{
+
+type integer INT1
+with {variant "FIELDLENGTH(8)" };
+
+type record RAW_PDU_112 {
+ INT1 ptr1,
+ INT1 ptr2,
+ BIT4 field1,
+ BIT4 field2 }
+
+with { variant (ptr1) "POINTERTO(field1)";
+ variant (ptr1) "UNIT(1)";
+ variant (ptr1) "PTROFFSET(ptr1)";
+ variant (ptr2) "POINTERTO(field2)";
+ variant (ptr2) "UNIT(1)"
+ variant (ptr2) "PTROFFSET(ptr2)"}
+
+} with {encode "RAW" };
+
+external function enc_RAW_PDU_112(in RAW_PDU_112 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_112(in octetstring stream) return RAW_PDU_112 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PTROFFSET_is_set_to_default_base() runs on TempComp{
+ const RAW_PDU_112 i := {16,12,'0110'B,'1001'B}
+ const octetstring o := '100C96'O
+
+ if ((enc_RAW_PDU_112(i) == o)and(dec_RAW_PDU_112(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_112(i)= ", enc_RAW_PDU_112(i), "; dec_RAW_PDU_112(o)= ", dec_RAW_PDU_112(o));}
+}
+
+// PTROFFSET is set to the beginning of record
+
+//type bitstring BIT3 length (3)
+//type hexstring HEX1 length (1)
+//type octetstring OCT3 length (3)
+
+group RAW_group6{
+
+//type integer INT1
+//with { encode "RAW"; variant "FIELDLENGTH(8)" };
+
+
+type record RAW_PDU_113 {
+ INT1 ptr1,
+ INT1 ptr2,
+ INT1 ptr3,
+
+ BIT3 field1,
+ HEX1 field2,
+ OCT3 field3 }
+
+with { variant (ptr1) "POINTERTO(field1)";
+ variant (ptr1) "UNIT(1)";
+ variant (ptr1) "PTROFFSET(ptr1)";
+ variant (ptr2) "POINTERTO(field2)";
+ variant (ptr2) "UNIT(1)";
+ variant (ptr2) "PTROFFSET(ptr1)";
+ variant (ptr3) "POINTERTO(field3)";
+ variant (ptr3) "UNIT(1)";
+ variant (ptr3) "PTROFFSET(ptr1)"}
+
+} with {encode "RAW" };
+
+external function enc_RAW_PDU_113(in RAW_PDU_113 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_113(in octetstring stream) return RAW_PDU_113 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PTROFFSET_is_set_to_the_beginning_of_record() runs on TempComp{
+ const RAW_PDU_113 i := {24,27,31,'111'B,'A'H,'010203'O}
+ const octetstring o := '181B1FD7008101'O
+
+ if ((enc_RAW_PDU_113(i) == o)and(dec_RAW_PDU_113(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_113(i)= ", enc_RAW_PDU_113(i), "; dec_RAW_PDU_113(o)= ", dec_RAW_PDU_113(o));}
+}
+
+// PTROFFSET is set to data field
+
+//type bitstring BIT3 length (3)
+//type hexstring HEX1 length (1)
+//type octetstring OCT3 length (3)
+
+group RAW_group7{
+
+//type integer INT1
+//with { variant "FIELDLENGTH(8)" };
+
+
+type record RAW_PDU_114 {
+ INT1 ptr1,
+ INT1 ptr2,
+ INT1 ptr3,
+
+ BIT3 field1,
+ HEX1 field2,
+ OCT3 field3 }
+
+with { variant (ptr1) "POINTERTO(field1)";
+ variant (ptr1) "UNIT(1)";
+ variant (ptr1) "PTROFFSET(field1)";
+ variant (ptr2) "POINTERTO(field2)";
+ variant (ptr2) "UNIT(1)";
+ variant (ptr2) "PTROFFSET(field1)";
+ variant (ptr3) "POINTERTO(field3)";
+ variant (ptr3) "UNIT(1)";
+ variant (ptr3) "PTROFFSET(field1)"}
+
+} with {encode "RAW" };
+
+external function enc_RAW_PDU_114(in RAW_PDU_114 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_114(in octetstring stream) return RAW_PDU_114 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_PTROFFSET_is_set_to_data_field() runs on TempComp{
+ const RAW_PDU_114 i := {0,3,7,'111'B,'A'H,'010203'O}
+ const octetstring o := '000307D7008101'O
+
+ if ((enc_RAW_PDU_114(i) == o)and(dec_RAW_PDU_114(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_114(i)= ", enc_RAW_PDU_114(i), "; dec_RAW_PDU_114(o)= ", dec_RAW_PDU_114(o));}
+}
+
+// ==== Testing HEXORDER Attribute ===
+
+//HEXORDER(low) for hexstring
+type hexstring RAW_PDU_115
+with { encode "RAW"; variant "HEXORDER(low)"};
+
+external function enc_RAW_PDU_115(in RAW_PDU_115 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_115(in octetstring stream) return RAW_PDU_115 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_HEXORDER_low_for_hexstring() runs on TempComp{
+ const RAW_PDU_115 i := '1234567890'H
+ const octetstring o := '2143658709'O
+
+ if ((enc_RAW_PDU_115(i) == o)and(dec_RAW_PDU_115(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_115(i)= ", enc_RAW_PDU_115(i), "; dec_RAW_PDU_115(o)= ", dec_RAW_PDU_115(o));}
+}
+
+//HEXORDER(high) for hexstring
+
+type hexstring RAW_PDU_116
+with { encode "RAW"; variant "HEXORDER(high)"};
+
+external function enc_RAW_PDU_116(in RAW_PDU_116 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_116(in octetstring stream) return RAW_PDU_116 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_HEXORDER_high_for_hexstring() runs on TempComp{
+ const RAW_PDU_116 i := '1234567890'H
+ const octetstring o := '1234567890'O
+
+ if ((enc_RAW_PDU_116(i) == o)and(dec_RAW_PDU_116(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_116(i)= ", enc_RAW_PDU_116(i), "; dec_RAW_PDU_116(o)= ", dec_RAW_PDU_116(o));}
+}
+
+// EXTENSION_BIT(no) for octetstring
+
+type octetstring RAW_PDU_117n
+with { encode "RAW"; variant "EXTENSION_BIT(no)"};
+
+external function enc_RAW_PDU_117n(in RAW_PDU_117n pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_117n(in octetstring stream) return RAW_PDU_117n with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_no_for_octetstring() runs on TempComp{
+ const RAW_PDU_117n i := '1234567890'O
+ const octetstring o := '1234567890'O
+
+ if ((enc_RAW_PDU_117n(i) == o)and(dec_RAW_PDU_117n(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_117n(i)= ", enc_RAW_PDU_117n(i), "; dec_RAW_PDU_117n(o)= ", dec_RAW_PDU_117n(o));}
+}
+
+// EXTENSION_BIT(yes) for octetstring
+
+type octetstring RAW_PDU_117
+with { encode "RAW"; variant "EXTENSION_BIT(yes)"};
+
+external function enc_RAW_PDU_117(in RAW_PDU_117 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_117(in octetstring stream) return RAW_PDU_117 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_yes_for_octetstring() runs on TempComp{
+ const RAW_PDU_117 i := '010203040500'O
+ const octetstring o := '010203040580'O
+
+ if ((enc_RAW_PDU_117(i) == o)and(dec_RAW_PDU_117(o) == '010203040580'O )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_117(i)= ", enc_RAW_PDU_117(i), "; dec_RAW_PDU_117(o)= ", dec_RAW_PDU_117(o));}
+}
+
+// EXTENSION_BIT(reverse) for octetstring
+
+type octetstring RAW_PDU_118
+with { encode "RAW"; variant "EXTENSION_BIT(reverse)"};
+
+external function enc_RAW_PDU_118(in RAW_PDU_118 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_118(in octetstring stream) return RAW_PDU_118 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_reverse_for_octetstring() runs on TempComp{
+ const RAW_PDU_118 i := '010203040500'O
+ const octetstring o := '818283848500'O
+
+ if ((enc_RAW_PDU_118(i) == o)and(dec_RAW_PDU_118(o) == '818283848500'O )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_118(i)= ", enc_RAW_PDU_118(i), "; dec_RAW_PDU_118(o)= ", dec_RAW_PDU_118(o));}
+}
+
+// EXTENSION_BIT(yes) for record of octetstring
+
+type octetstring OCT1
+with { encode "RAW"; variant "FIELDLENGTH(1)"};
+
+type record of OCT1 RAW_PDU_119
+with { encode "RAW"; variant "EXTENSION_BIT(yes)"};
+
+external function enc_RAW_PDU_119(in RAW_PDU_119 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_119(in octetstring stream) return RAW_PDU_119 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_yes_for_record_of_octetstring() runs on TempComp{
+ const RAW_PDU_119 i := {'84'O, '00'O}
+ const octetstring o := '0480'O
+
+ if ((enc_RAW_PDU_119(i) == o)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_119(i)= ", enc_RAW_PDU_119(i), "; dec_RAW_PDU_119(o)= ", dec_RAW_PDU_119(o));}
+}
+
+// EXTENSION_BIT(reverse) for record of octetstring
+//type octetstring OCT1
+//with { encode "RAW"; variant "FIELDLENGTH(1)"};
+
+type record of OCT1 RAW_PDU_119r
+with { encode "RAW"; variant "EXTENSION_BIT(reverse)"};
+
+external function enc_RAW_PDU_119r(in RAW_PDU_119r pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_119r(in octetstring stream) return RAW_PDU_119r with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_reverse_for_record_of_octetstring() runs on TempComp{
+ const RAW_PDU_119r i := {'80'O}
+ const octetstring o := '00'O
+
+ if ((enc_RAW_PDU_119r(i) == o)and(dec_RAW_PDU_119r(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_119r(i)= ", enc_RAW_PDU_119r(i), "; dec_RAW_PDU_119r(o)= ", dec_RAW_PDU_119r(o));}
+}
+
+// EXTENSION_BIT(no) for record of octetstring
+//type octetstring OCT1
+//with { encode "RAW"; variant "FIELDLENGTH(1)"};
+
+type record of OCT1 RAW_PDU_120
+with { encode "RAW"; variant "EXTENSION_BIT(no)"};
+
+external function enc_RAW_PDU_120(in RAW_PDU_120 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_120(in octetstring stream) return RAW_PDU_120 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_no_for_record_of_octetstring() runs on TempComp{
+ const RAW_PDU_120 i := {'84'O, '05'O}
+ const octetstring o := '8405'O
+
+ if ((enc_RAW_PDU_120(i) == o)and(dec_RAW_PDU_120(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_120(i)= ", enc_RAW_PDU_120(i), "; dec_RAW_PDU_120(o)= ", dec_RAW_PDU_120(o));}
+}
+
+// EXTENSION_BIT(yes) for record of bitstring
+
+type bitstring BIT3_
+with { encode "RAW"; variant "FIELDLENGTH(3)"};
+
+type record of BIT3_ RAW_PDU_121
+with { encode "RAW"; variant "EXTENSION_BIT(yes)"};
+
+external function enc_RAW_PDU_121(in RAW_PDU_121 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_121(in octetstring stream) return RAW_PDU_121 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_yes_for_record_of_bitstring() runs on TempComp{
+ const RAW_PDU_121 i := {'111'B, '000'B, '111'B}
+ const octetstring o := 'C301'O
+
+ if ((enc_RAW_PDU_121(i) == o)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_121(i)= ", enc_RAW_PDU_121(i), "; dec_RAW_PDU_121(o)= ", dec_RAW_PDU_121(o));}
+}
+
+//EXTENSION_BIT(reverse) for record of bitstring
+
+//type bitstring BIT3
+//with { encode "RAW"; variant "FIELDLENGTH(3)"};
+
+type record of BIT3_ RAW_PDU_122
+with { encode "RAW"; variant "EXTENSION_BIT(reverse)"};
+
+external function enc_RAW_PDU_122(in RAW_PDU_122 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_122(in octetstring stream) return RAW_PDU_122 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_reverse_for_record_of_bitstring() runs on TempComp{
+ const RAW_PDU_122 i := {'111'B, '000'B, '111'B}
+ const octetstring o := 'E700'O
+
+ if ((enc_RAW_PDU_122(i) == o)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_122(i)= ", enc_RAW_PDU_122(i), "; dec_RAW_PDU_122(o)= ", dec_RAW_PDU_122(o));}
+}
+
+// EXTENSION_BIT(yes) for set of bitstring
+
+type set of BIT3 RAW_PDU_123
+with { encode "RAW"; variant "EXTENSION_BIT(yes)"};
+
+external function enc_RAW_PDU_123(in RAW_PDU_123 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_123(in octetstring stream) return RAW_PDU_123 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_yes_for_set_of_bitstring() runs on TempComp{
+ const RAW_PDU_123 i := {'111'B, '000'B, '111'B}
+ const octetstring o := 'C301'O
+
+ if ((enc_RAW_PDU_123(i) == o)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_123(i)= ", enc_RAW_PDU_123(i), "; dec_RAW_PDU_123(o)= ", dec_RAW_PDU_123(o));}
+}
+
+// EXTENSION_BIT(reverse) for set of bitstring
+
+type set of BIT3 RAW_PDU_124
+with { encode "RAW"; variant "EXTENSION_BIT(reverse)"};
+
+external function enc_RAW_PDU_124(in RAW_PDU_124 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_124(in octetstring stream) return RAW_PDU_124 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_reverse_for_set_of_bitstring() runs on TempComp{
+ const RAW_PDU_124 i := {'111'B, '000'B, '111'B}
+ const octetstring o := 'E700'O
+
+ if ((enc_RAW_PDU_124(i) == o)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_124(i)= ", enc_RAW_PDU_124(i), "; dec_RAW_PDU_124(o)= ", dec_RAW_PDU_124(o));}
+}
+
+
+
+// EXTENSION_BIT(yes) for set of hexstring
+
+type set of hexstring RAW_PDU_125
+with { encode "RAW"; variant "EXTENSION_BIT(yes)"};
+
+external function enc_RAW_PDU_125(in RAW_PDU_125 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_125(in octetstring stream) return RAW_PDU_125 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_yes_for_set_of_hexstring() runs on TempComp{
+ const RAW_PDU_125 i := {'F'H, '0'H, 'F'H}
+ const octetstring o := '070F'O
+log("kamu");
+ if ((enc_RAW_PDU_125(i) == o)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_125(i)= ", enc_RAW_PDU_125(i), "; dec_RAW_PDU_125(o)= ", dec_RAW_PDU_125(o));}
+ log("end");
+}
+
+// EXTENSION_BIT(reverse) for set of hexstring
+
+type set of hexstring RAW_PDU_126
+with { encode "RAW"; variant "EXTENSION_BIT(reverse)"};
+
+external function enc_RAW_PDU_126(in RAW_PDU_126 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_126(in octetstring stream) return RAW_PDU_126 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_reverse_for_set_of_hexstring() runs on TempComp{
+ const RAW_PDU_126 i := {'F'H, '00'H, 'FFF'H}
+ const octetstring o := '0FF87F'O;
+
+ if ((enc_RAW_PDU_126(i) == o)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_126(i)= ", enc_RAW_PDU_126(i), "; dec_RAW_PDU_126(o)= ", dec_RAW_PDU_126(o));}
+}
+
+// Test of record with EXTENSION_BIT 1
+
+group RAW_group8{
+
+type bitstring BIT1_
+with { variant "FIELDLENGTH(1)" } ;
+
+type bitstring BIT7_
+with { variant "FIELDLENGTH(7)" } ;
+
+type octetstring OCT3_
+with { variant "FIELDLENGTH(3)" } ;
+
+
+type record Rec1
+{ BIT7_ data ,
+ BIT1_ extensionbit }
+ with { variant "EXTENSION_BIT (yes)"};
+
+
+type record Rec2
+{ BIT7_ data ,
+ BIT1_ extensionbit }
+ with { variant "EXTENSION_BIT (yes)"};
+
+
+type record Rec3
+{ BIT7_ data ,
+ BIT1_ extensionbit }
+ with { variant "EXTENSION_BIT (yes)"};
+
+
+type record Octet1
+{ BIT7_ data ,
+ BIT1_ extensionbit ,
+ Rec1 rec1 ,
+ octetstring more_extension optional }
+ with { variant "EXTENSION_BIT (yes)";
+ variant (more_extension) "EXTENSION_BIT (yes)"};
+
+
+type record Octet2
+{ BIT7_ data ,
+ BIT1_ extensionbit ,
+ Rec2 rec2 ,
+ octetstring more_extension optional }
+ with { variant "EXTENSION_BIT (yes)";
+ variant (more_extension) "EXTENSION_BIT (yes)"};
+
+
+type record Octet3
+{ BIT7_ data ,
+ BIT1_ extensionbit ,
+ Rec3 rec3 ,
+ octetstring more_extension optional }
+ with { variant "EXTENSION_BIT (yes)";
+ variant (more_extension) "EXTENSION_BIT (yes)"};
+
+
+type record RAW_PDU_127
+{ OCT3_ octstr ,
+ integer length1 ,
+ Octet1 oct1 ,
+ Octet2 oct2 optional ,
+ Octet3 oct3 optional }
+ with { variant (length1) "LENGTHTO(oct1 , oct2 , oct3 )" }
+
+} with {encode "RAW"}
+
+external function enc_RAW_PDU_127(in RAW_PDU_127 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_127(in octetstring stream) return RAW_PDU_127 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_record_with_EXTENSION_BIT_1() runs on TempComp{
+
+const RAW_PDU_127
+ i := { octstr := '123456'O ,
+ length1 := 15 ,
+ oct1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B ,
+ rec1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B } ,
+ more_extension := '000080'O } ,
+ oct2 :=
+ { data := '0000010'B ,
+ extensionbit := '0'B ,
+ rec2 :=
+ { data := '0000010'B ,
+ extensionbit := '0'B } ,
+ more_extension := '000080'O } ,
+ oct3 :=
+ { data := '0000011'B ,
+ extensionbit := '0'B ,
+ rec3 :=
+ { data := '0000011'B ,
+ extensionbit := '0'B } ,
+ more_extension := '000080'O } }
+
+ const octetstring o :='1234560F010100008002020000800303000080'O
+
+ if ((enc_RAW_PDU_127(i) == o)and(dec_RAW_PDU_127(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_127(i)= ", enc_RAW_PDU_127(i), "; dec_RAW_PDU_127(o)= ", dec_RAW_PDU_127(o));}
+}
+
+// Test of record with EXTENSION_BIT 2
+
+//external function enc_RAW_PDU_127(in RAW_PDU_127 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+//external function dec_RAW_PDU_127(in octetstring stream) return RAW_PDU_128 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_record_with_EXTENSION_BIT_2() runs on TempComp{
+ const RAW_PDU_127
+ i := { octstr := '123456'O ,
+ length1 := 12 ,
+ oct1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B ,
+ rec1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B } ,
+ more_extension := '000080'O } ,
+ oct2 :=
+ { data := '0000010'B ,
+ extensionbit := '0'B ,
+ rec2 :=
+ { data := '0000010'B ,
+ extensionbit := '1'B } ,
+ more_extension := omit } ,
+ oct3 :=
+ { data := '0000011'B ,
+ extensionbit := '0'B ,
+ rec3 :=
+ { data := '0000011'B ,
+ extensionbit := '0'B } ,
+ more_extension := '000080'O } }
+
+
+ const octetstring o :='1234560C010100008002820303000080'O
+
+ if ((enc_RAW_PDU_127(i) == o)and(dec_RAW_PDU_127(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_127(i)= ", enc_RAW_PDU_127(i), "; dec_RAW_PDU_127(o)= ", dec_RAW_PDU_127(o));}
+}
+
+// Test of record with EXTENSION_BIT 3
+
+testcase TC_record_with_EXTENSION_BIT_3() runs on TempComp{
+ const RAW_PDU_127
+ i := { octstr := '123456'O ,
+ length1 := 9 ,
+ oct1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B ,
+ rec1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B } ,
+ more_extension := '000080'O } ,
+ oct2 :=
+ { data := '0000010'B ,
+ extensionbit := '0'B ,
+ rec2 :=
+ { data := '0000010'B ,
+ extensionbit := '1'B } ,
+ more_extension := omit } ,
+ oct3 :=
+ { data := '0000011'B ,
+ extensionbit := '0'B ,
+ rec3 :=
+ { data := '0000011'B ,
+ extensionbit := '1'B } ,
+ more_extension := omit } }
+
+ const octetstring o :='12345609010100008002820383'O
+
+ if ((enc_RAW_PDU_127(i) == o)and(dec_RAW_PDU_127(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_127(i)= ", enc_RAW_PDU_127(i), "; dec_RAW_PDU_127(o)= ", dec_RAW_PDU_127(o));}
+}
+
+// Test of record with EXTENSION_BIT 4
+
+testcase TC_record_with_EXTENSION_BIT_4() runs on TempComp{
+ const RAW_PDU_127
+ i := { octstr := '123456'O ,
+ length1 := 6 ,
+ oct1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B ,
+ rec1 :=
+ { data := '0000001'B ,
+ extensionbit := '1'B } ,
+ more_extension := omit } ,
+ oct2 :=
+ { data := '0000010'B ,
+ extensionbit := '0'B ,
+ rec2 :=
+ { data := '0000010'B ,
+ extensionbit := '1'B } ,
+ more_extension := omit } ,
+ oct3 :=
+ { data := '0000011'B ,
+ extensionbit := '0'B ,
+ rec3 :=
+ { data := '0000011'B ,
+ extensionbit := '1'B } ,
+ more_extension := omit } }
+
+ const octetstring o :='12345606018102820383'O
+
+ if ((enc_RAW_PDU_127(i) == o)and(dec_RAW_PDU_127(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_127(i)= ", enc_RAW_PDU_127(i), "; dec_RAW_PDU_127(o)= ", dec_RAW_PDU_127(o));}
+}
+
+// Test of record with EXTENSION_BIT 5
+
+testcase TC_record_with_EXTENSION_BIT_5() runs on TempComp{
+ const RAW_PDU_127
+ i := { octstr := '123456'O ,
+ length1 := 4 ,
+ oct1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B ,
+ rec1 :=
+ { data := '0000001'B ,
+ extensionbit := '1'B } ,
+ more_extension := omit } ,
+ oct2 :=
+ { data := '0000010'B ,
+ extensionbit := '0'B ,
+ rec2 :=
+ { data := '0000010'B ,
+ extensionbit := '1'B } ,
+ more_extension := omit } ,
+ oct3 := omit }
+
+ const octetstring o :='1234560401810282'O
+
+
+ if ((enc_RAW_PDU_127(i) == o)and(dec_RAW_PDU_127(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_127(i)= ", enc_RAW_PDU_127(i), "; dec_RAW_PDU_127(o)= ", dec_RAW_PDU_127(o));}
+}
+
+// Test of record with EXTENSION_BIT 6
+testcase TC_record_with_EXTENSION_BIT_6() runs on TempComp{
+ const RAW_PDU_127
+ i := { octstr := '123456'O ,
+ length1 := 2 ,
+ oct1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B ,
+ rec1 :=
+ { data := '0000001'B ,
+ extensionbit := '1'B } ,
+ more_extension := omit } ,
+ oct2 := omit ,
+ oct3 := omit }
+
+ const octetstring o :='123456020181'O
+
+ if ((enc_RAW_PDU_127(i) == o)and(dec_RAW_PDU_127(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_127(i)= ", enc_RAW_PDU_127(i), "; dec_RAW_PDU_127(o)= ", dec_RAW_PDU_127(o));}
+}
+
+// Test of record with EXTENSION_BIT 7
+testcase TC_record_with_EXTENSION_BIT_7() runs on TempComp{
+ const RAW_PDU_127
+ i := { octstr := '123456'O ,
+ length1 := 15 ,
+ oct1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B ,
+ rec1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B } ,
+ more_extension := '000080'O } ,
+ oct2 :=
+ { data := '0000010'B ,
+ extensionbit := '0'B ,
+ rec2 :=
+ { data := '0000010'B ,
+ extensionbit := '0'B } ,
+ more_extension := '000080'O } ,
+ oct3 :=
+ { data := '0000011'B ,
+ extensionbit := '0'B ,
+ rec3 :=
+ { data := '0000011'B ,
+ extensionbit := '0'B } ,
+ more_extension := '000080'O } }
+
+ const octetstring o :='1234560F010100008002020000800303000080'O
+
+ if ((enc_RAW_PDU_127(i) == o)and(dec_RAW_PDU_127(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_127(i)= ", enc_RAW_PDU_127(i), "; dec_RAW_PDU_127(o)= ", dec_RAW_PDU_127(o));}
+}
+
+// Test of record with EXTENSION_BIT 8
+testcase TC_record_with_EXTENSION_BIT_8() runs on TempComp{
+ const RAW_PDU_127
+ i := { octstr := '123456'O ,
+ length1 := 5 ,
+ oct1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B ,
+ rec1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B } ,
+ more_extension := '000080'O } ,
+ oct2 := omit ,
+ oct3 := omit }
+
+ const octetstring o :='123456050101000080'O
+
+ if ((enc_RAW_PDU_127(i) == o)and(dec_RAW_PDU_127(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_127(i)= ", enc_RAW_PDU_127(i), "; dec_RAW_PDU_127(o)= ", dec_RAW_PDU_127(o));}
+}
+
+// Test of record with EXTENSION_BIT 9
+testcase TC_record_with_EXTENSION_BIT_9() runs on TempComp{
+ const RAW_PDU_127
+ i := { octstr := '123456'O ,
+ length1 := 10 ,
+ oct1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B ,
+ rec1 :=
+ { data := '0000001'B ,
+ extensionbit := '0'B } ,
+ more_extension := '000080'O } ,
+ oct2 :=
+ { data := '0000010'B ,
+ extensionbit := '0'B ,
+ rec2 :=
+ { data := '0000010'B ,
+ extensionbit := '0'B } ,
+ more_extension := '000080'O } ,
+ oct3 := omit }
+
+ const octetstring o :='1234560A01010000800202000080'O
+
+ if ((enc_RAW_PDU_127(i) == o)and(dec_RAW_PDU_127(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_127(i)= ", enc_RAW_PDU_127(i), "; dec_RAW_PDU_127(o)= ", dec_RAW_PDU_127(o));}
+}
+
+// EXTENSION_BIT_GROUP(no)
+
+group RAW_group9{
+
+//type bitstring BIT1 length(1);
+//type bitstring BIT7 length(7);
+
+type record RAW_PDU_128 {
+ BIT7_ field1,
+ BIT1_ ext1,
+ BIT7_ field2,
+ BIT1_ ext2,
+ BIT7_ field3,
+ BIT1_ ext3
+}with { variant "EXTENSION_BIT_GROUP(no, field1, ext3)"};
+
+}with {encode "RAW"}
+
+external function enc_RAW_PDU_128(in RAW_PDU_128 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_128(in octetstring stream) return RAW_PDU_128 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_GROUP_no() runs on TempComp{
+ const RAW_PDU_128
+ i := {'1111111'B, '0'B, '1110000'B, '0'B,'0001111'B,'0'B}
+ const octetstring o := '7F700F'O
+
+ if ((enc_RAW_PDU_128(i) == o)and(dec_RAW_PDU_128(o) == i )) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_128(i)= ", enc_RAW_PDU_128(i), "; dec_RAW_PDU_128(o)= ", dec_RAW_PDU_128(o));}
+}
+
+// EXTENSION_BIT_GROUP(yes)
+
+
+group RAW_group10{
+
+//type bitstring BIT1 length(1);
+//type bitstring BIT7 length(7);
+
+type record RAW_PDU_129 {
+ BIT7_ field1,
+ BIT1_ ext1,
+ BIT7_ field2,
+ BIT1_ ext2,
+ BIT7_ field3,
+ BIT1_ ext3
+}with { variant "EXTENSION_BIT_GROUP(yes, field1, ext2)"};
+
+}with {encode "RAW"}
+
+external function enc_RAW_PDU_129(in RAW_PDU_129 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_129(in octetstring stream) return RAW_PDU_129 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_GROUP_yes() runs on TempComp{
+ const RAW_PDU_129 i := {'1111111'B, '0'B, '1110000'B, '0'B,'0001111'B,'0'B};
+ const octetstring o := '7FF00F'O;
+
+ if ((enc_RAW_PDU_129(i) == o)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_129(i)= ", enc_RAW_PDU_129(i), "; dec_RAW_PDU_129(o)= ", dec_RAW_PDU_129(o));}
+}
+
+// EXTENSION_BIT_GROUP(yes) - two groups
+
+group RAW_group11{
+
+//type bitstring BIT1 length(1);
+//type bitstring BIT7 length(7);
+
+type record RAW_PDU_130 {
+ BIT7_ field1,
+ BIT1_ ext1,
+ BIT7_ field2,
+ BIT1_ ext2,
+ BIT7_ field3,
+ BIT1_ ext3,
+ BIT7_ field4,
+ BIT1_ ext4
+
+}with { variant "EXTENSION_BIT_GROUP(yes, field1, ext2)"
+ variant "EXTENSION_BIT_GROUP(yes, field3, ext4)"};
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_130(in RAW_PDU_130 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_130(in octetstring stream) return RAW_PDU_130 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_GROUP_yes_2_groups() runs on TempComp{
+ const RAW_PDU_130 i := {'1111111'B, '0'B, '1110000'B, '0'B,'0001111'B,'0'B, '1111111'B, '0'B}
+ const octetstring o := '7FF00FFF'O
+
+ if ((enc_RAW_PDU_130(i) == o)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_130(i)= ", enc_RAW_PDU_130(i), "; dec_RAW_PDU_130(o)= ", dec_RAW_PDU_130(o));}
+}
+
+// EXTENSION_BIT_GROUP(yes, reverse) - two groups
+
+group RAW_group12{
+
+//type bitstring BIT1 length(1);
+//type bitstring BIT7 length(7);
+
+type record RAW_PDU_131 {
+ BIT7_ field1,
+ BIT1_ ext1,
+ BIT7_ field2,
+ BIT1_ ext2,
+ BIT7_ field3,
+ BIT1_ ext3,
+ BIT7_ field4,
+ BIT1_ ext4
+
+}with { variant "EXTENSION_BIT_GROUP(yes, field1, ext2)"
+ variant "EXTENSION_BIT_GROUP(reverse, field3, ext4)"};
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_131(in RAW_PDU_131 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_131(in octetstring stream) return RAW_PDU_131 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_EXTENSION_BIT_GROUP_yes_reverse_2_groups() runs on TempComp{
+ const RAW_PDU_131 i := {'1111111'B, '0'B, '1110000'B, '0'B,'0001111'B,'0'B, '1111111'B, '0'B}
+ const octetstring o := '7FF08F7F'O
+
+ if ((enc_RAW_PDU_131(i) == o)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_131(i)= ", enc_RAW_PDU_131(i), "; dec_RAW_PDU_131(o)= ", dec_RAW_PDU_131(o));}
+}
+
+//==== Testing ALIGN Attribute ====
+
+//ALIGN(right) for octetstring
+
+type octetstring RAW_PDU_132
+with { encode "RAW";
+ variant "FIELDLENGTH(4)";
+ variant "ALIGN (right)"
+ };
+external function enc_RAW_PDU_132(in RAW_PDU_132 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_132(in octetstring stream) return RAW_PDU_132 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_ALIGN_right_for_octetstring() runs on TempComp{
+ const RAW_PDU_132 i := '123456'O
+ const octetstring o := '00123456'O
+
+ if ((enc_RAW_PDU_132(i) == o)and((dec_RAW_PDU_132(o) == '00'O & i))) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_132(i)= ", enc_RAW_PDU_132(i), "; dec_RAW_PDU_132(o)= ", dec_RAW_PDU_132(o));}
+}
+
+//ALIGN(left) for octetstring
+
+type octetstring RAW_PDU_133
+with { encode "RAW";
+ variant "FIELDLENGTH(4)";
+ variant "ALIGN (left)"
+ };
+external function enc_RAW_PDU_133(in RAW_PDU_133 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_133(in octetstring stream) return RAW_PDU_133 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_ALIGN_left_for_octetstring() runs on TempComp{
+ const RAW_PDU_133 i := '123456'O
+ const octetstring o := '12345600'O
+
+ if ((enc_RAW_PDU_133(i) == o)and((dec_RAW_PDU_133(o) == i & '00'O))) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_133(i)= ", enc_RAW_PDU_133(i), "; dec_RAW_PDU_133(o)= ", dec_RAW_PDU_133(o));}
+}
+
+// ALIGN(right) for bitstring
+
+type bitstring RAW_PDU_134
+with { encode "RAW";
+ variant "FIELDLENGTH(16)";
+ variant "ALIGN (right)"
+ };
+
+external function enc_RAW_PDU_134(in RAW_PDU_134 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_134(in octetstring stream) return RAW_PDU_134 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_ALIGN_right_for_bitstring() runs on TempComp{
+ const RAW_PDU_134 i := '11111111'B
+ const octetstring o := 'FF00'O
+
+ if ((enc_RAW_PDU_134(i) == o)and((dec_RAW_PDU_134(o) == '00000000'B & i ))) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_134(i)= ", enc_RAW_PDU_134(i), "; dec_RAW_PDU_134(o)= ", dec_RAW_PDU_134(o));}
+}
+
+// ALIGN(left) for bitstring
+
+type bitstring RAW_PDU_135
+with { encode "RAW";
+ variant "FIELDLENGTH(16)";
+ variant "ALIGN (left)"
+ };
+
+external function enc_RAW_PDU_135(in RAW_PDU_135 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_135(in octetstring stream) return RAW_PDU_135 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_ALIGN_left_for_bitstring() runs on TempComp{
+ const RAW_PDU_135 i := '11111111'B
+ const octetstring o := '00FF'O
+
+ if ((enc_RAW_PDU_135(i) == o)and((dec_RAW_PDU_135(o) == i & '00000000'B ))) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_135(i)= ", enc_RAW_PDU_135(i), "; dec_RAW_PDU_135(o)= ", dec_RAW_PDU_135(o));}
+}
+
+//======= Testing Compound types ======
+
+// Test of record with integer and octetstring
+
+group RAW_group13{
+
+type record RAW_PDU_136
+{ integer int ,
+ octetstring octstr }
+with { variant (int) "FIELDLENGTH(8)" ;
+ variant (octstr) "FIELDLENGTH(2)" } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_136(in RAW_PDU_136 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_136(in octetstring stream) return RAW_PDU_136 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_record_with_integer_and_octetstring() runs on TempComp{
+ const RAW_PDU_136
+ i := { int := 20 ,
+ octstr := '1234'O }
+
+ const octetstring o := '141234'O
+
+ if ((enc_RAW_PDU_136(i) == o)and((dec_RAW_PDU_136(o) == i))) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_136(i)= ", enc_RAW_PDU_136(i), "; dec_RAW_PDU_136(o)= ", dec_RAW_PDU_136(o));}
+}
+
+// Test of record with default values in field
+group RAW_group14{
+
+type record RAW_PDU_137
+{ integer int ,
+ octetstring octstr }
+with { variant (int) "" ;
+ variant (octstr) "FIELDLENGTH(2)" } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_137(in RAW_PDU_137 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_137(in octetstring stream) return RAW_PDU_137 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_record_with_default_values_in_field() runs on TempComp{
+ const RAW_PDU_137
+ i := { int := 20 ,
+ octstr := '1234'O }
+
+ const octetstring o := '141234'O
+
+ if ((enc_RAW_PDU_137(i) == o)and((dec_RAW_PDU_137(o) == i))) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_137(i)= ", enc_RAW_PDU_137(i), "; dec_RAW_PDU_137(o)= ", dec_RAW_PDU_137(o));}
+}
+
+// Test of record with bitstring
+
+group RAW_group15{
+
+type record RAW_PDU_138
+{ integer int ,
+ octetstring octstr ,
+ bitstring bit6 ,
+ bitstring bit2 }
+
+with { variant (int) "" ;
+ variant (octstr) "FIELDLENGTH(2)" ;
+ variant (bit6) "FIELDLENGTH(6)" ;
+ variant (bit2) "FIELDLENGTH(2)"
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_138(in RAW_PDU_138 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_138(in octetstring stream) return RAW_PDU_138 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_record_with_bitstring() runs on TempComp{
+ const RAW_PDU_138
+ i := { int := 20 ,
+ octstr := '1234'O ,
+ bit6 := '111111'B ,
+ bit2 := '00'B
+ }
+
+ const octetstring o := '1412343F'O
+
+ if ((enc_RAW_PDU_138(i) == o)and((dec_RAW_PDU_138(o) == i))) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_138(i)= ", enc_RAW_PDU_138(i), "; dec_RAW_PDU_138(o)= ", dec_RAW_PDU_138(o));}
+}
+
+//Test of record with enumerated and fieldlength calculation
+
+group RAW_group16{
+
+type enumerated enum
+{ zero, first, second, third, fourth, fifth, sixth, seventh, eighth, nineth,
+tenth }
+with { variant ""};
+
+type record RAW_PDU_139
+ { integer int ,
+ octetstring octstr ,
+ bitstring bit6 ,
+ bitstring bit2 ,
+ enum enum1 ,
+ integer length1 ,
+ octetstring octN }
+
+with {variant (int) "" ;
+ variant (octstr) "FIELDLENGTH(2)" ;
+ variant (bit6) "FIELDLENGTH(6)" ;
+ variant (bit2) "FIELDLENGTH(2)" ;
+ variant (enum1) "FIELDLENGTH(8)" ;
+ variant (length1) "LENGTHTO(octN)" ;
+ variant (octN) ""
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_139(in RAW_PDU_139 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_139(in octetstring stream) return RAW_PDU_139 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_record_with_enumerated_and_fieldlength_calculation() runs on TempComp{
+ const RAW_PDU_139
+ i := { int := 20 ,
+ octstr := '1234'O ,
+ bit6 := '111111'B ,
+ bit2 := '00'B ,
+ enum1 := tenth ,
+ length1:= 3 ,
+ octN := '123456'O
+
+ }
+
+
+
+const octetstring o := '1412343F0A03123456'O
+
+
+ if ((enc_RAW_PDU_139(i) == o)and((dec_RAW_PDU_139(o) == i))) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_139(i)= ", enc_RAW_PDU_139(i), "; dec_RAW_PDU_139(o)= ", dec_RAW_PDU_139(o));}
+}
+
+// Test of record called from record
+
+group RAW_encode1{
+
+//type enumerated Enum2
+//{ zero, first, second, third, fourth, fifth, sixth, seventh, eighth, nineth,
+//tenth }
+//with { variant ""} ;
+
+
+type record record1
+ { bitstring bit1 ,
+ bitstring bit3 ,
+ bitstring bit4 ,
+ integer int ,
+ integer length1 ,
+ octetstring octN }
+with { variant (bit1) "FIELDLENGTH(1)" ;
+ variant (bit3) "FIELDLENGTH(3)" ;
+ variant (bit4) "FIELDLENGTH(4)" ;
+ variant (int) "FIELDLENGTH(16)" ;
+ variant (length1) "LENGTHTO(octN)" ;
+ variant (octN) ""
+ }
+
+
+type record RAW_PDU_140
+ { integer int ,
+ octetstring octstr ,
+ bitstring bit6 ,
+ bitstring bit2 ,
+ enum enum1 ,
+ integer length1 ,
+ octetstring octN ,
+ integer length2 ,
+ record1 rec1 }
+
+with { variant (int) "" ;
+ variant (octstr) "FIELDLENGTH(2)" ;
+ variant (bit6) "FIELDLENGTH(6)" ;
+ variant (bit2) "FIELDLENGTH(2)" ;
+ variant (enum1) "FIELDLENGTH(8)" ;
+ variant (length1) "LENGTHTO(octN)" ;
+ variant (octN) "" ;
+ variant (length2) "LENGTHTO(rec1)" ;
+ variant (rec1) ""
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_140(in RAW_PDU_140 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_140(in octetstring stream) return RAW_PDU_140 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_record_called_from_record() runs on TempComp{
+ const RAW_PDU_140
+ i := { int := 20 ,
+ octstr := '1234'O ,
+ bit6 := '111111'B ,
+ bit2 := '00'B ,
+ enum1 := tenth ,
+ length1:= 3 ,
+ octN := '123456'O ,
+ length2:= 7 ,
+ rec1 := { bit1 := '1'B ,
+ bit3 := '000'B ,
+ bit4 := '1111'B ,
+ int := 4660 ,
+ length1 := 3 ,
+ octN := 'FFFFFF'O }
+
+ }
+
+ const octetstring o := '1412343F0A0312345607F1341203FFFFFF'O
+
+ if ((enc_RAW_PDU_140(i) == o)and((dec_RAW_PDU_140(o) == i))) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_140(i)= ", enc_RAW_PDU_140(i), "; dec_RAW_PDU_140(o)= ", dec_RAW_PDU_140(o));}
+}
+
+// Test of union called from record with CROSSTAG
+
+group RAW_group17{
+
+//type enumerated enum
+//{ zero, first, second, third, fourth, fifth, sixth, seventh, eighth, nineth,
+//tenth }
+//with { variant ""} ;
+
+
+//type record record1
+// { bitstring bit1 ,
+// bitstring bit3 ,
+// bitstring bit4 ,
+// integer int ,
+// integer length1 ,
+// octetstring octN }
+//with { variant (bit1) "FIELDLENGTH(1)" ;
+// variant (bit3) "FIELDLENGTH(3)" ;
+// variant (bit4) "FIELDLENGTH(4)" ;
+// variant (int) "FIELDLENGTH(16)" ;
+// variant (length1) "LENGTHTO(octN)" ;
+// variant (octN) ""
+// }
+
+type union optionalpart
+{ integer one ,
+ integer two ,
+ integer three ,
+ integer four ,
+ integer five }
+with { variant (one) "" ;
+ variant (two) "" ;
+ variant (three) "" ;
+ variant (four) "" ;
+ variant (five) "" ;
+ }
+
+type record RAW_PDU_141
+ { integer int ,
+ octetstring octstr ,
+ bitstring bit6 ,
+ bitstring bit2 ,
+ enum enum1 ,
+ integer length1 ,
+ octetstring octN ,
+ integer length2 ,
+ record1 rec1 ,
+ integer id ,
+ integer opt_part_ptr ,
+ optionalpart opt_part ,
+ octetstring eop }
+
+with { variant (int) "" ;
+ variant (octstr) "FIELDLENGTH(2)" ;
+ variant (bit6) "FIELDLENGTH(6)" ;
+ variant (bit2) "FIELDLENGTH(2)" ;
+ variant (enum1) "FIELDLENGTH(8)" ;
+ variant (length1) "LENGTHTO(octN)" ;
+ variant (octN) "" ;
+ variant (length2) "LENGTHTO(rec1)" ;
+ variant (rec1) "" ;
+ variant (id) "" ;
+ variant (opt_part_ptr) "POINTERTO ( opt_part)";
+ variant (opt_part) "CROSSTAG (
+ one , id = 1 ;
+ two , id = 2 ;
+ three , id = 3 ;
+ four , id = 4 ;
+ five , id = 5 ) ";
+
+ variant (eop) "FIELDLENGTH(1)" ;
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_141(in RAW_PDU_141 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_141(in octetstring stream) return RAW_PDU_141 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_union_called_from_record_with_CROSSTAG() runs on TempComp{
+ const RAW_PDU_141
+ i := { int := 20 ,
+ octstr := '1234'O ,
+ bit6 := '111111'B ,
+ bit2 := '00'B ,
+ enum1 := tenth ,
+ length1:= 3 ,
+ octN := '123456'O ,
+ length2:= 7 ,
+ rec1 := { bit1 := '1'B ,
+ bit3 := '000'B ,
+ bit4 := '1111'B ,
+ int := 4660 ,
+ length1 := 3 ,
+ octN := 'FFFFFF'O } ,
+ id := 5 ,
+ opt_part_ptr:= 1 ,
+ opt_part := { five := 5 } ,
+ eop := '00'O
+ }
+
+ const octetstring o := '1412343F0A0312345607F1341203FFFFFF05010500'O
+
+ if ((enc_RAW_PDU_141(i) == o)and((dec_RAW_PDU_141(o) == i))) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_141(i)= ", enc_RAW_PDU_141(i), "; dec_RAW_PDU_141(o)= ", dec_RAW_PDU_141(o));}
+}
+
+// Test of union called from record with CROSSTAG, OTHERWISE
+
+group RAW_group18{
+
+//type enumerated enum
+//{ zero, first, second, third, fourth, fifth, sixth, seventh, eighth, nineth,
+//tenth }
+//with { variant ""} ;
+
+
+//type record record1
+// { bitstring bit1 ,
+// bitstring bit3 ,
+// bitstring bit4 ,
+// integer int ,
+// integer length1 ,
+// octetstring octN }
+//with { variant (bit1) "FIELDLENGTH(1)" ;
+// variant (bit3) "FIELDLENGTH(3)" ;
+// variant (bit4) "FIELDLENGTH(4)" ;
+// variant (int) "FIELDLENGTH(16)" ;
+// variant (length1) "LENGTHTO(octN)" ;
+// variant (octN) ""
+// }
+
+
+
+//type union optionalpart
+//{ integer one ,
+// integer two ,
+// integer three ,
+// integer four ,
+// integer five }
+//with { variant (one) "" ;
+// variant (two) "" ;
+// variant (three) "" ;
+// variant (four) "" ;
+// variant (five) "" ;
+// }
+
+
+
+
+
+type record RAW_PDU_142
+ { integer int ,
+ octetstring octstr ,
+ bitstring bit6 ,
+ bitstring bit2 ,
+ enum enum1 ,
+ integer length1 ,
+ octetstring octN ,
+ integer length2 ,
+ record1 rec1 ,
+ integer id ,
+ integer opt_part_ptr ,
+ optionalpart opt_part ,
+ octetstring eop }
+
+with { variant (int) "" ;
+ variant (octstr) "FIELDLENGTH(2)" ;
+ variant (bit6) "FIELDLENGTH(6)" ;
+ variant (bit2) "FIELDLENGTH(2)" ;
+ variant (enum1) "FIELDLENGTH(8)" ;
+ variant (length1) "LENGTHTO(octN)" ;
+ variant (octN) "" ;
+ variant (length2) "LENGTHTO(rec1)" ;
+ variant (rec1) "" ;
+ variant (id) "" ;
+ variant (opt_part_ptr) "POINTERTO ( opt_part)";
+ variant (opt_part) "CROSSTAG (
+ one , id = 1 ;
+ two , id = 2 ;
+ three , id = 3 ;
+ four , id = 4 ;
+ five , OTHERWISE ) ";
+
+ variant (eop) "FIELDLENGTH(1)" ;
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_142(in RAW_PDU_142 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_142(in octetstring stream) return RAW_PDU_142 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_union_called_from_record_with_CROSSTAG_OTHERWISE() runs on TempComp{
+ const RAW_PDU_142
+ i := { int := 20 ,
+ octstr := '1234'O ,
+ bit6 := '111111'B ,
+ bit2 := '00'B ,
+ enum1 := tenth ,
+ length1:= 3 ,
+ octN := '123456'O ,
+ length2:= 7 ,
+ rec1 := { bit1 := '1'B ,
+ bit3 := '000'B ,
+ bit4 := '1111'B ,
+ int := 4660 ,
+ length1 := 3 ,
+ octN := 'FFFFFF'O } ,
+ id := 5 ,
+ opt_part_ptr:= 1 ,
+ opt_part := { five := 5 } ,
+ eop := '00'O
+ }
+
+ const octetstring o := '1412343F0A0312345607F1341203FFFFFF05010500'O
+
+ if ((enc_RAW_PDU_142(i) == o)and((dec_RAW_PDU_142(o) == i))) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_142(i)= ", enc_RAW_PDU_142(i), "; dec_RAW_PDU_142(o)= ", dec_RAW_PDU_142(o));}
+}
+
+
+// Test of record without specifying the default attributes for fields
+
+group RAW_group19 {
+
+//type enumerated enum
+//{ zero, first, second, third, fourth, fifth, sixth, seventh, eighth, nineth,
+//tenth }
+//with { variant ""} ;
+
+
+type record record1_2
+ { bitstring bit1 ,
+ bitstring bit3 ,
+ bitstring bit4 ,
+ integer int ,
+ integer length1 ,
+ octetstring octN }
+with { variant (bit1) "FIELDLENGTH(1)" ;
+ variant (bit3) "FIELDLENGTH(3)" ;
+ variant (bit4) "FIELDLENGTH(4)" ;
+ variant (int) "FIELDLENGTH(16)" ;
+ variant (length1) "LENGTHTO(octN)"
+ }
+
+
+
+type union optionalpart1
+{ integer one ,
+ integer two ,
+ integer three ,
+ integer four ,
+ integer five }
+with { variant "" }
+
+
+type record RAW_PDU_143
+ { integer int ,
+ octetstring octstr ,
+ bitstring bit6 ,
+ bitstring bit2 ,
+ enum enum1 ,
+ integer length1 ,
+ octetstring octN ,
+ integer length2 ,
+ record1_2 rec1 ,
+ integer id ,
+ integer opt_part_ptr ,
+ optionalpart1 opt_part ,
+ octetstring eop }
+
+with { variant (octstr) "FIELDLENGTH(2)" ;
+ variant (bit6) "FIELDLENGTH(6)" ;
+ variant (bit2) "FIELDLENGTH(2)" ;
+ variant (enum1) "FIELDLENGTH(8)" ;
+ variant (length1) "LENGTHTO(octN)" ;
+ variant (length2) "LENGTHTO(rec1)" ;
+ variant (opt_part_ptr) "POINTERTO ( opt_part)";
+ variant (opt_part) "CROSSTAG (
+ one , id = 1 ;
+ two , id = 2 ;
+ three , id = 3 ;
+ four , id = 4 ;
+ five , id = 5 ) ";
+
+ variant (eop) "FIELDLENGTH(1)" ;
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_143(in RAW_PDU_143 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_143(in octetstring stream) return RAW_PDU_143 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_record_without_specifying_the_default_attributes_for_fields() runs on TempComp{
+
+ const RAW_PDU_143
+ i := { int := 20 ,
+ octstr := '1234'O ,
+ bit6 := '111111'B ,
+ bit2 := '00'B ,
+ enum1 := tenth ,
+ length1:= 3 ,
+ octN := '123456'O ,
+ length2:= 7 ,
+ rec1 := { bit1 := '1'B ,
+ bit3 := '000'B ,
+ bit4 := '1111'B ,
+ int := 4660 ,
+ length1 := 3 ,
+ octN := 'FFFFFF'O } ,
+ id := 5 ,
+ opt_part_ptr:= 1 ,
+ opt_part := { five := 5 } ,
+ eop := '00'O
+ }
+
+
+
+ const octetstring o := '1412343F0A0312345607F1341203FFFFFF05010500'O
+
+ if ((enc_RAW_PDU_143(i) == o)and(dec_RAW_PDU_143(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_143(i)= ", enc_RAW_PDU_143(i), "; dec_RAW_PDU_143(o)= ", dec_RAW_PDU_143(o));}
+
+}
+
+
+// Test of record of called from record
+
+
+group RAW_group20{
+
+type record record2
+ { octetstring oct1 ,
+ integer length2 ,
+ octetstring octN }
+with { variant (oct1) "FIELDLENGTH(1)";
+ variant (length2) "LENGTHTO(octN)"
+ }
+
+type record of record2 Rec2list
+with { variant "" };
+
+type record RAW_PDU_144
+ { integer length1 ,
+ Rec2list rec2list }
+
+with { variant (length1) "LENGTHTO(rec2list)" } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_144(in RAW_PDU_144 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_144(in octetstring stream) return RAW_PDU_144 with { extension "prototype(convert) decode(RAW)" }
+
+
+testcase TC_record_of_called_from_record() runs on TempComp{
+ const RAW_PDU_144
+ i := { length1:= 8 ,
+ rec2list := { { oct1 := '12'O ,
+ length2 := 2 ,
+ octN := '3456'O } ,
+ { oct1 := '12'O ,
+ length2 := 2 ,
+ octN := '7890'O } }
+ }
+
+ const octetstring o := '081202345612027890'O
+
+
+ if ((enc_RAW_PDU_144(i) == o)and(dec_RAW_PDU_144(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_144(i)= ", enc_RAW_PDU_144(i), "; dec_RAW_PDU_144(o)= ", dec_RAW_PDU_144(o));}
+}
+
+
+// Test of set with TAG
+
+group RAW_group21{
+
+type record intrec
+ { integer tag ,
+ integer intfield }
+with { variant ""} ;
+
+
+type record octrec
+ { integer tag ,
+ octetstring octfield }
+with { variant (octfield) "FIELDLENGTH(2)"} ;
+
+
+type record bitrec
+ { integer tag ,
+ bitstring bit8field }
+with { variant (bit8field) "FIELDLENGTH(8)"} ;
+
+
+
+type set RAW_PDU_145
+ { intrec int ,
+ octrec octstr ,
+ bitrec bit8 }
+
+with { variant "TAG (
+ int , tag=1 ;
+ octstr , tag=2 ;
+ bit8 , tag=3 )"
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_145(in RAW_PDU_145 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_145(in octetstring stream) return RAW_PDU_145 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_set_with_TAG () runs on TempComp{
+
+ const RAW_PDU_145
+ i := { octstr := { tag := 2 ,
+ octfield := '1234'O } ,
+ int := { tag := 1 ,
+ intfield := 15 } ,
+ bit8 := { tag := 3 ,
+ bit8field := '11111111'B }
+ }
+
+
+
+ const octetstring o := '010F02123403FF'O
+
+
+ if ((enc_RAW_PDU_145(i) == o)and(dec_RAW_PDU_145(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_145(i)= ", enc_RAW_PDU_145(i), "; dec_RAW_PDU_145(o)= ", dec_RAW_PDU_145(o));}
+}
+
+// Test of union with TAG , first element called
+
+group RAW_group22{
+
+//type record intrec
+// { integer tag ,
+// integer intfield }
+//with { variant ""} ;
+
+
+// type record octrec
+// { integer tag ,
+// octetstring octfield }
+// with { variant (octfield) "FIELDLENGTH(2)"} ;
+
+
+// type record bitrec
+// { integer tag ,
+// bitstring bit8field }
+// with { variant (bit8field) "FIELDLENGTH(8)"} ;
+
+
+
+type union RAW_PDU_146
+ { intrec int ,
+ octrec octstr ,
+ bitrec bit8 }
+
+with { variant "TAG (
+ int , tag=1 ;
+ octstr , tag=2 ;
+ bit8 , tag=3 )"
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_146(in RAW_PDU_146 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_146(in octetstring stream) return RAW_PDU_146 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_union_with_TAG_first_element_called() runs on TempComp {
+ const RAW_PDU_146
+ i := { int := { tag := 1 ,
+ intfield := 15 }
+ }
+
+ const octetstring o := '010F'O
+
+ if ((enc_RAW_PDU_146(i) == o)and(dec_RAW_PDU_146(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_146(i)= ", enc_RAW_PDU_146(i), "; dec_RAW_PDU_146(o)= ", dec_RAW_PDU_146(o));}
+
+}
+
+// Test of union with TAG , second element called
+
+//external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+//external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
+
+// group RAW_group{
+//
+// type record intrec
+// { integer tag ,
+// integer intfield }
+// with { variant ""} ;
+//
+//
+// type record octrec
+// { integer tag ,
+// octetstring octfield }
+// with { variant (octfield) "FIELDLENGTH(2)"} ;
+//
+//
+// type record bitrec
+// { integer tag ,
+// bitstring bit8field }
+// with { variant (bit8field) "FIELDLENGTH(8)"} ;
+//
+//
+//
+// type union RAW_PDU
+// { intrec int ,
+// octrec octstr ,
+// bitrec bit8 }
+//
+// with { variant "TAG (
+// int , tag=1 ;
+// octstr , tag=2 ;
+// bit8 , tag=3)"
+// } ;
+//
+// }with{encode "RAW"}
+
+testcase TC_union_with_TAG_second_element_called() runs on TempComp {
+ const RAW_PDU_146
+ i := { octstr := { tag := 2 ,
+ octfield := '1234'O }
+ }
+
+
+
+ const octetstring o := '021234'O
+
+ if ((enc_RAW_PDU_146(i) == o)and(dec_RAW_PDU_146(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_146(i)= ", enc_RAW_PDU_146(i), "; dec_RAW_PDU_146(o)= ", dec_RAW_PDU_146(o));}
+
+}
+
+// Test of union with TAG , third element called
+
+testcase TC_union_with_TAG_third_element_called() runs on TempComp {
+ const RAW_PDU_146
+ i := { bit8 := { tag := 3 ,
+ bit8field := '11111111'B }
+ }
+
+
+
+ const octetstring o := '03FF'O
+
+
+ if ((enc_RAW_PDU_146(i) == o)and(dec_RAW_PDU_146(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_146(i)= ", enc_RAW_PDU_146(i), "; dec_RAW_PDU_146(o)= ", dec_RAW_PDU_146(o));}
+
+}
+
+// Test of union with TAG , third element called with OTHERWISE
+
+group RAW_group23{
+
+type union RAW_PDU_147
+ { intrec field1 ,
+ octrec field2 ,
+ bitrec field3}
+
+with { variant "TAG (
+ field1, tag=1 ;
+ field2, tag=2 ;
+ field3, OTHERWISE)"};
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_147(in RAW_PDU_147 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_147(in octetstring stream) return RAW_PDU_147 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_union_with_TAG_third_element_called_with_OTHERWISE() runs on TempComp {
+ const RAW_PDU_147
+ i := { field3 := { tag := 3 ,
+ bit8field := '11111111'B }
+ }
+
+ const octetstring o := '03FF'O
+
+
+ if ((enc_RAW_PDU_147(i) == o)and(dec_RAW_PDU_147(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_147(i)= ", enc_RAW_PDU_147(i), "; dec_RAW_PDU_147(o)= ", dec_RAW_PDU_147(o));}
+
+}
+
+// Test of set of called from record
+
+group RAW_group24{
+
+// type record record2
+// { octetstring oct1 ,
+// integer length2 ,
+// octetstring octN }
+// with { variant (oct1) "FIELDLENGTH(1)";
+// variant (length2) "LENGTHTO(octN)"
+//
+// }
+
+type set of record2 Rec2list_1
+with { variant "" };
+
+type record RAW_PDU_148
+ { integer length1 ,
+ Rec2list_1 rec2list }
+
+with { variant (length1) "LENGTHTO(rec2list)" } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_148(in RAW_PDU_148 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_148(in octetstring stream) return RAW_PDU_148 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_set_of_called_from_record() runs on TempComp{
+
+ const RAW_PDU_148
+ i := { length1:= 8 ,
+ rec2list := { { oct1 := '12'O ,
+ length2 := 2 ,
+ octN := '3456'O } ,
+ { oct1 := '12'O ,
+ length2 := 2 ,
+ octN := '7890'O } }
+ }
+
+
+ const octetstring o := '081202345612027890'O
+
+ if ((enc_RAW_PDU_148(i) == o)and(dec_RAW_PDU_148(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_148(i)= ", enc_RAW_PDU_148(i), "; dec_RAW_PDU_148(o)= ", dec_RAW_PDU_148(o));}
+
+}
+
+// Test of record with optional field with PRESENCE
+
+group RAW_group25{
+
+// type enumerated enum
+// { zero, first, second, third, fourth, fifth, sixth, seventh, eighth, nineth,
+// tenth }
+// with { variant ""} ;
+
+
+// type record record1_2
+// { bitstring bit1 ,
+// bitstring bit3 ,
+// bitstring bit4 ,
+// integer int ,
+// integer length1 ,
+// octetstring octN }
+// with { variant (bit1) "FIELDLENGTH(1)" ;
+// variant (bit3) "FIELDLENGTH(3)" ;
+// variant (bit4) "FIELDLENGTH(4)" ;
+// variant (int) "FIELDLENGTH(16)" ;
+// variant (length1) "LENGTHTO(octN)"
+// }
+
+
+// type union optionalpart1
+// { integer one ,
+// integer two ,
+// integer three ,
+// integer four ,
+// integer five }
+// with { variant "" }
+
+
+// type record record2
+// { octetstring oct1 ,
+// integer length2 ,
+// octetstring octN }
+// with { variant (oct1) "FIELDLENGTH(1)";
+// variant (length2) "LENGTHTO(octN)"
+// }
+//
+//
+// type record of record2 Rec2list
+// with { variant "" };
+
+type record RAW_PDU_149
+ { integer int ,
+ octetstring octstr ,
+ bitstring bit6 ,
+ bitstring bit2 ,
+ enum enum1 ,
+ integer length1 ,
+ octetstring octN ,
+ integer length2 ,
+ record1_2 rec1 ,
+ integer length3 ,
+ Rec2list rec2list ,
+ integer id ,
+ integer opt_part_ptr ,
+ integer presenceid ,
+ optionalpart1 opt_part optional ,
+ octetstring eop optional }
+
+with { variant (octstr) "FIELDLENGTH(2)" ;
+ variant (bit6) "FIELDLENGTH(6)" ;
+ variant (bit2) "FIELDLENGTH(2)" ;
+ variant (enum1) "FIELDLENGTH(8)" ;
+ variant (length1) "LENGTHTO(octN)" ;
+ variant (length2) "LENGTHTO(rec1)" ;
+ variant (length3) "LENGTHTO(rec2list)"
+ variant (opt_part_ptr) "POINTERTO ( opt_part)";
+ variant (opt_part) "PRESENCE (presenceid= 1)" ;
+ variant (opt_part) "CROSSTAG (
+ one , id = 1 ;
+ two , id = 2 ;
+ three , id = 3 ;
+ four , id = 4 ;
+ five , id = 5 ) ";
+
+ variant (eop) "FIELDLENGTH(1)" ;
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_149(in RAW_PDU_149 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_149(in octetstring stream) return RAW_PDU_149 with { extension "prototype(convert) decode(RAW)" }
+
+
+testcase TC_record_with_optional_field_with_PRESENCE() runs on TempComp{
+
+ const RAW_PDU_149
+ i := { int := 20 ,
+ octstr := '1234'O ,
+ bit6 := '111111'B ,
+ bit2 := '00'B ,
+ enum1 := tenth ,
+ length1:= 3 ,
+ octN := '123456'O ,
+ length2:= 7 ,
+ rec1 := { bit1 := '1'B ,
+ bit3 := '000'B ,
+ bit4 := '1111'B ,
+ int := 4660 ,
+ length1 := 3 ,
+ octN := 'FFFFFF'O } ,
+ length3:= 8 ,
+ rec2list := { { oct1 := '12'O ,
+ length2 := 2 ,
+ octN := '3456'O } ,
+ { oct1 := '12'O ,
+ length2 := 2 ,
+ octN := '7890'O } } ,
+ id := 5 ,
+ opt_part_ptr:= 2 ,
+ presenceid := 1 ,
+ opt_part := { five := 5 } ,
+ eop := '00'O
+ }
+
+ const octetstring o := '1412343F0A0312345607F1341203FFFFFF0812023456120278900502010500'O
+
+ if ((enc_RAW_PDU_149(i) == o)and(dec_RAW_PDU_149(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_149(i)= ", enc_RAW_PDU_149(i), "; dec_RAW_PDU_149(o)= ", dec_RAW_PDU_149(o));}
+
+}
+
+// Test of record with UNIT
+
+
+group RAW_group26{
+
+type integer INT1_1
+with { variant "" } ;
+
+
+
+type record RAW_PDU_150
+{ INT1_1 length1 ,
+ octetstring octstr }
+with { variant (length1) "LENGTHTO(octstr)" ;
+ variant (length1) "UNIT(8)" } ;
+
+}with{encode "RAW"}
+
+
+external function enc_RAW_PDU_150(in RAW_PDU_150 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_150(in octetstring stream) return RAW_PDU_150 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_record_with_UNIT() runs on TempComp{
+ const RAW_PDU_150
+ i := { length1 := 4 ,
+ octstr := '12345678'O }
+
+ const octetstring o := '0412345678'O
+
+
+ if ((enc_RAW_PDU_150(i) == o)and(dec_RAW_PDU_150(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_150(i)= ", enc_RAW_PDU_150(i), "; dec_RAW_PDU_150(o)= ", dec_RAW_PDU_150(o));}
+}
+
+// Test of record with PTRUNIT
+
+group RAW_group27{
+
+type record RAW_PDU_151
+{ integer pointer1 ,
+ integer pointer2 ,
+ integer pointer3 ,
+ octetstring octstr1 ,
+ octetstring octstr2 ,
+ octetstring octstr3 }
+with { variant (pointer1) "POINTERTO(octstr1)" ;
+ variant (pointer1) "PTRUNIT(1)" ;
+ variant (pointer2) "POINTERTO(octstr2)" ;
+ variant (pointer3) "POINTERTO(octstr3)" ;
+ variant (octstr1) "FIELDLENGTH(3)" ;
+ variant (octstr2) "FIELDLENGTH(3)" ;
+ variant (octstr3) "FIELDLENGTH(3)" ;
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_151(in RAW_PDU_151 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_151(in octetstring stream) return RAW_PDU_151 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_record_with_PTRUNIT() runs on TempComp{
+ const RAW_PDU_151
+ i := { pointer1 := 24 ,
+ pointer2 := 5 ,
+ pointer3 := 7 ,
+ octstr1 := '010203'O ,
+ octstr2 := '040506'O ,
+ octstr3 := '070809'O }
+
+ const octetstring o := '180507010203040506070809'O
+
+ if ((enc_RAW_PDU_151(i) == o)and(dec_RAW_PDU_151(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_151(i)= ", enc_RAW_PDU_151(i), "; dec_RAW_PDU_151(o)= ", dec_RAW_PDU_151(o));}
+}
+
+// Test of record with PTROFFSET
+
+
+
+group RAW_group28{
+
+type record RAW_PDU_152
+{ integer pointer1 ,
+ integer pointer2 ,
+ integer pointer3 ,
+ octetstring octstr1 ,
+ octetstring octstr2 ,
+ octetstring octstr3 }
+with { variant (pointer1) "POINTERTO(octstr1)" ;
+ variant (pointer1) "PTROFFSET(0)" ;
+ variant (pointer2) "POINTERTO(octstr2)" ;
+ variant (pointer3) "POINTERTO(octstr3)" ;
+ variant (octstr1) "FIELDLENGTH(3)" ;
+ variant (octstr2) "FIELDLENGTH(3)" ;
+ variant (octstr3) "FIELDLENGTH(3)" ;
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_152(in RAW_PDU_152 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_152(in octetstring stream) return RAW_PDU_152 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_record_with_PTROFFSET() runs on TempComp{
+ const RAW_PDU_152
+ i := { pointer1 := 3 ,
+ pointer2 := 5 ,
+ pointer3 := 7 ,
+ octstr1 := '010203'O ,
+ octstr2 := '040506'O ,
+ octstr3 := '070809'O }
+
+
+
+ const octetstring o := '030507010203040506070809'O
+
+
+ if ((enc_RAW_PDU_152(i) == o)and(dec_RAW_PDU_152(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_152(i)= ", enc_RAW_PDU_152(i), "; dec_RAW_PDU_152(o)= ", dec_RAW_PDU_152(o));}
+}
+
+// Test of structured types - 1
+
+
+
+group RAW_group29{
+
+type record Rec1field
+{ bitstring bit7 ,
+ bitstring bit1 ,
+ octetstring oct1 }
+with { variant (bit7) "FIELDLENGTH (7)" ;
+ variant (bit1) "FIELDLENGTH (1)" ;
+ variant (oct1) "FIELDLENGTH (1)" ;
+ };
+
+type enumerated Enum1
+{zero, first, second, third, fourth, fifth }
+with { variant "FIELDLENGTH (8)" };
+
+
+type record Rec3_1
+{ integer int ,
+ octetstring octstr ,
+ bitstring bitstr }
+with { variant (octstr) "FIELDLENGTH (1)" ;
+ variant (bitstr) "FIELDLENGTH (8)" ;
+ };
+
+
+type record of Rec3_1 Recof
+with { variant "" };
+
+type record Rec5
+{ integer length1 ,
+ octetstring octN }
+with { variant (length1) "LENGTHTO (octN)" };
+
+type union Rec2content
+{ Enum1 enum1 ,
+ Recof recof ,
+ Rec5 rec5 }
+with { variant "" };
+
+type record Rec2data
+{ octetstring id ,
+ integer length1 ,
+ octetstring octN ,
+ integer length2 ,
+ Rec2content content }
+with { variant (id) "FIELDLENGTH (1)" ;
+ variant (length1) "LENGTHTO (octN)" ;
+ variant (length2) "LENGTHTO (content)" ;
+ variant (content) "CROSSTAG (
+ enum1 , id='01'O ;
+ recof , id='02'O ;
+ rec5 , id='03'O ) "
+ };
+
+type set of Rec2data Rec2datas
+ with { variant "" };
+
+
+
+type record RAW_PDU_153
+{ integer length1 ,
+ Rec1field rec1field1 ,
+ integer length2 ,
+ Rec1field rec1field2 ,
+ Rec2datas datas }
+with { variant (length1) "LENGTHTO(rec1field1)" ;
+ variant (length2) "LENGTHTO(rec1field2)"
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_153(in RAW_PDU_153 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_153(in octetstring stream) return RAW_PDU_153 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_structured_types_1() runs on TempComp{
+ const RAW_PDU_153
+ i := { length1 := 2 ,
+ rec1field1 := { bit7 := '0000001'B ,
+ bit1 := '1'B ,
+ oct1:= 'FF'O } ,
+ length2 := 2 ,
+ rec1field2 := { bit7 := '0000010'B ,
+ bit1 := '1'B ,
+ oct1:= 'FF'O } ,
+ datas :={ { id := '01'O ,
+ length1 := 2 ,
+ octN := '1234'O ,
+ length2 := 1 ,
+ content := { enum1 := fifth } },
+ { id := '02'O ,
+ length1 := 2 ,
+ octN := '5678'O,
+ length2 := 6 ,
+ content := { recof := { { int := 1 ,
+ octstr := 'FF'O ,
+ bitstr := '00000000'B } ,
+ { int := 2 ,
+ octstr := 'FF'O ,
+ bitstr := '00000000'B } } } } ,
+ { id := '03'O ,
+ length1 := 2 ,
+ octN := '9012'O,
+ length2 := 6 ,
+ content := { rec5 := { length1 := 5 ,
+ octN := '1234567890'O } } } } }
+
+
+
+ const octetstring o := '0281FF0282FF010212340105020256780601FF0002FF000302901206051234567890'O
+
+
+
+ if ((enc_RAW_PDU_153(i) == o)and(dec_RAW_PDU_153(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_153(i)= ", enc_RAW_PDU_153(i), "; dec_RAW_PDU_153(o)= ", dec_RAW_PDU_153(o));}
+}
+
+// Test of structured types - 2
+
+external function enc_RAW_PDU_154(in RAW_PDU_154 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_154(in octetstring stream) return RAW_PDU_154 with { extension "prototype(convert) decode(RAW)" }
+
+group RAW_group30{
+
+type octetstring end_of_optional_parameters_indicator
+with { variant "FIELDLENGTH(1)"};
+
+type integer pointer
+with { variant "" };
+
+// type integer INT1_1
+// with { variant "" };
+
+type record Rec1_1
+{ bitstring bit4 ,
+ bitstring bit1 ,
+ bitstring bit3 ,
+ INT1_1 length1 ,
+ octetstring octN optional }
+with { variant (bit4) "FIELDLENGTH(4)" ;
+ variant (bit1) "FIELDLENGTH(1)" ;
+ variant (bit3) "FIELDLENGTH(3)" ;
+ variant (length1) "LENGTHTO(octN)" ;
+ };
+
+
+
+type record Rec2_1
+{ bitstring bit8 ,
+ INT1_1 length1 ,
+ octetstring octN optional }
+with { variant (bit8) "FIELDLENGTH(8)" ;
+ variant (length1) "LENGTHTO(octN)" ;
+ };
+
+
+type record Rec3_2
+{ bitstring bit4 ,
+ bitstring bit1 ,
+ bitstring bit3 ,
+ integer int ,
+ octetstring oct2 optional }
+with { variant (bit4) "FIELDLENGTH(4)" ;
+ variant (bit1) "FIELDLENGTH(1)" ;
+ variant (bit3) "FIELDLENGTH(3)" ;
+ variant (oct2) "FIELDLENGTH(2)" ;
+ };
+
+
+
+type record Rec4
+{ integer int ,
+ octetstring oct5 optional }
+with { variant (oct5) "FIELDLENGTH(5)"};
+
+
+
+
+type union opt_par_union
+{ octetstring octstr ,
+ Rec2_1 rec2 ,
+ Rec3_2 rec3 ,
+ Rec4 rec4 }
+ with { variant (octstr) "FIELDLENGTH(2)" };
+
+
+type record opt_par
+{ integer id ,
+ integer length1 ,
+ opt_par_union par }
+with { variant (length1) "LENGTHTO(par)" ;
+ variant (par) "CROSSTAG(
+ octstr , id=1 ;
+ rec2 , id=2 ;
+ rec3 , id=3 ;
+ rec4 , id=4 ; )"
+ } ;
+
+
+type set of opt_par optional_part
+ with { variant "" };
+
+
+type record RAW_PDU_154
+{ pointer var_part_ptr,
+ pointer opt_part_ptr,
+ INT1_1 length1,
+ Rec1_1 rec1 optional,
+ optional_part opt_part optional,
+ end_of_optional_parameters_indicator EndOP optional
+} with { variant (var_part_ptr) "POINTERTO (length1)";
+ variant (opt_part_ptr) "POINTERTO (opt_part)";
+ variant (length1) "LENGTHTO (rec1)" };
+
+}with{encode "RAW"}
+
+testcase TC_structured_types_2() runs on TempComp{
+ const RAW_PDU_154
+ i := { var_part_ptr := 2 ,
+ opt_part_ptr := 2 ,
+ length1 := 0 ,
+ rec1 := omit ,
+ opt_part := { { id := 1 , // opt_part := omit
+ length1 := 2 ,
+ par := { octstr := 'FFFF'O } } } ,
+ EndOP := '00'O } // EndOP = omit
+
+
+ const octetstring o := '0202000102FFFF00'O
+
+ if ((enc_RAW_PDU_154(i) == o)and(dec_RAW_PDU_154(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_154(i)= ", enc_RAW_PDU_154(i), "; dec_RAW_PDU_154(o)= ", dec_RAW_PDU_154(o));}
+}
+//=====================================
+//Test of structured types - 3
+//=====================================
+
+//group RAW_group31{
+
+// type octetstring end_of_optional_parameters_indicator
+// with { variant "FIELDLENGTH(1)"};
+//
+// type integer pointer
+// with { variant "" };
+
+// type integer INT1_1
+// with { variant "" };
+
+// type record Rec1_1
+// { bitstring bit4 ,
+// bitstring bit1 ,
+// bitstring bit3 ,
+// INT1 length1 ,
+// octetstring octN optional }
+// with { variant (bit4) "FIELDLENGTH(4)" ;
+// variant (bit1) "FIELDLENGTH(1)" ;
+// variant (bit3) "FIELDLENGTH(3)" ;
+// variant (length1) "LENGTHTO(octN)" ;
+// };
+
+// type record Rec2_1
+// { bitstring bit8 ,
+// INT1_1 length1 ,
+// octetstring octN optional }
+// with { variant (bit8) "FIELDLENGTH(8)" ;
+// variant (length1) "LENGTHTO(octN)" ;
+// };
+
+
+// type record Rec3_2
+// { bitstring bit4 ,
+// bitstring bit1 ,
+// bitstring bit3 ,
+// integer int ,
+// octetstring oct2 optional }
+// with { variant (bit4) "FIELDLENGTH(4)" ;
+// variant (bit1) "FIELDLENGTH(1)" ;
+// variant (bit3) "FIELDLENGTH(3)" ;
+// variant (oct2) "FIELDLENGTH(2)" ;
+// };
+
+// type record Rec4
+// { integer int ,
+// octetstring oct5 optional }
+// with { variant (oct5) "FIELDLENGTH(5)"};
+
+
+
+
+// type union opt_par_union
+// { octetstring octstr ,
+// Rec2_1 rec2 ,
+// Rec3_2 rec3 ,
+// Rec4 rec4 }
+// with { variant (octstr) "FIELDLENGTH(2)" };
+
+
+// type record opt_par
+// { integer id ,
+// integer length1 ,
+// opt_par_union par }
+// with { variant (length1) "LENGTHTO(par)" ;
+// variant (par) "CROSSTAG(
+// octstr , id=1 ;
+// rec2 , id=2 ;
+// rec3 , id=3 ;
+// rec4 , id=4 ; )"
+// } ;
+
+
+// type set of opt_par optional_part
+// with { variant "" };
+
+
+// type record RAW_PDU_155
+// { pointer var_part_ptr,
+// pointer opt_part_ptr,
+// INT1_1 length1,
+// Rec1_1 rec1 optional,
+// optional_part opt_part optional,
+// end_of_optional_parameters_indicator EndOP optional
+// } with { variant (var_part_ptr) "POINTERTO (length1)";
+// variant (opt_part_ptr) "POINTERTO (opt_part)";
+// variant (length1) "LENGTHTO (rec1)" };
+
+//}with{encode "RAW"}
+
+//external function enc_RAW_PDU_155(in RAW_PDU_155 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+//external function dec_RAW_PDU_155(in octetstring stream) return RAW_PDU_155 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_structured_types_3() runs on TempComp{
+ const RAW_PDU_154
+ i := { var_part_ptr := 2 ,
+ opt_part_ptr := 7 ,
+ length1 := 5 ,
+ rec1 := { bit4 := '1111'B , // rec1 := omit
+ bit1 := '1'B ,
+ bit3 := '000'B ,
+ length1 := 3 ,
+ octN := '123456'O } , // octN := omit
+ opt_part := { { id := 1 , // opt_part := omit
+ length1 := 2 ,
+ par := { octstr := 'FFFF'O } } } ,
+ EndOP := '00'O } // EndOP = omit
+
+
+
+ const octetstring o := '0207051F031234560102FFFF00'O
+
+ if ((enc_RAW_PDU_154(i) == o)and(dec_RAW_PDU_154(o) == i)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+//=====================================
+// Test of structured types - 4
+//=====================================
+
+//group RAW_group32{
+
+// type octetstring end_of_optional_parameters_indicator
+// with { variant "FIELDLENGTH(1)"};
+
+// type integer pointer
+// with { variant "" };
+
+// type integer INT1_1
+// with { variant "" };
+
+// type record Rec1_1
+// { bitstring bit4 ,
+// bitstring bit1 ,
+// bitstring bit3 ,
+// INT1_1 length1 ,
+// octetstring octN optional }
+// with { variant (bit4) "FIELDLENGTH(4)" ;
+// variant (bit1) "FIELDLENGTH(1)" ;
+// variant (bit3) "FIELDLENGTH(3)" ;
+// variant (length1) "LENGTHTO(octN)" ;
+// };
+
+
+
+// type record Rec2_1
+// { bitstring bit8 ,
+// INT1_1 length1 ,
+// octetstring octN optional }
+// with { variant (bit8) "FIELDLENGTH(8)" ;
+// variant (length1) "LENGTHTO(octN)" ;
+// };
+
+
+// type record Rec3_2
+// { bitstring bit4 ,
+// bitstring bit1 ,
+// bitstring bit3 ,
+// integer int ,
+// octetstring oct2 optional }
+// with { variant (bit4) "FIELDLENGTH(4)" ;
+// variant (bit1) "FIELDLENGTH(1)" ;
+// variant (bit3) "FIELDLENGTH(3)" ;
+// variant (oct2) "FIELDLENGTH(2)" ;
+// };
+
+// type record Rec4
+// { integer int ,
+// octetstring oct5 optional }
+// with { variant (oct5) "FIELDLENGTH(5)"};
+
+
+
+
+// type union opt_par_union
+// { octetstring octstr ,
+// Rec2_1 rec2 ,
+// Rec3_2 rec3 ,
+// Rec4 rec4 }
+// with { variant (octstr) "FIELDLENGTH(2)" };
+
+
+// type record opt_par
+// { integer id ,
+// integer length1 ,
+// opt_par_union par }
+// with { variant (length1) "LENGTHTO(par)" ;
+// variant (par) "CROSSTAG(
+// octstr , id=1 ;
+// rec2 , id=2 ;
+// rec3 , id=3 ;
+// rec4 , id=4 ; )"
+// } ;
+
+
+// type set of opt_par optional_part
+// with { variant "" };
+
+
+// type record RAW_PDU_156
+// { pointer var_part_ptr,
+// pointer opt_part_ptr,
+// INT1_1 length1,
+// Rec1_1 rec1 optional,
+// optional_part opt_part optional,
+// end_of_optional_parameters_indicator EndOP optional
+// } with { variant (var_part_ptr) "POINTERTO (length1)";
+// variant (opt_part_ptr) "POINTERTO (opt_part)";
+// variant (length1) "LENGTHTO (rec1)" };
+//
+// }with{encode "RAW"}
+
+//external function enc_RAW_PDU_156(in RAW_PDU_156 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+//external function dec_RAW_PDU_156(in octetstring stream) return RAW_PDU_156 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_structured_types_4() runs on TempComp{
+ const RAW_PDU_154
+ i := { var_part_ptr := 2 ,
+ opt_part_ptr := 7 ,
+ length1 := 5 ,
+ rec1 := { bit4 := '1111'B , // rec1 := omit
+ bit1 := '1'B ,
+ bit3 := '000'B ,
+ length1 := 3 ,
+ octN := '123456'O } , // octN := omit
+ opt_part := { { id := 1 , // opt_part := omit
+ length1 := 2 ,
+ par := { octstr := 'FFFF'O } } ,
+ { id := 2 ,
+ length1 := 7 ,
+ par := { rec2:= { bit8 := '00000000'B ,
+ length1 := 5 ,
+ octN := '1234567890'O } } } , // octN := omit
+ { id := 3 ,
+ length1 := 4 ,
+ par := { rec3 := { bit4 := '1111'B ,
+ bit1 := '0'B ,
+ bit3 := '100'B ,
+ int := 15 ,
+ oct2 := '1234'O } } } , // oct2 := omit
+ { id := 4 ,
+ length1 := 6 ,
+ par := { rec4:= { int := 15 ,
+ oct5 := '1234567890'O } } } } , // oct5 := omit
+ EndOP := '00'O } // EndOP = omit
+
+
+
+ const octetstring o := '0207051F031234560102FFFF02070005123456789003048F0F123404060F123456789000'O
+
+ if ((enc_RAW_PDU_154(i) == o)and(dec_RAW_PDU_154(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_154(i)= ", enc_RAW_PDU_154(i), "; dec_RAW_PDU_154(o)= ", dec_RAW_PDU_154(o));}
+}
+
+// Test of structured types - 5
+
+//external function enc_RAW_PDU(in RAW_PDU pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+//external function dec_RAW_PDU(in octetstring stream) return RAW_PDU with { extension "prototype(convert) decode(RAW)" }
+
+//group RAW_group{
+
+// type octetstring end_of_optional_parameters_indicator
+// with { variant "FIELDLENGTH(1)"};
+
+// type integer pointer
+// with { variant "" };
+
+// type integer INT1
+// with { variant "" };
+
+// type record Rec1_1
+// { bitstring bit4 ,
+// bitstring bit1 ,
+// bitstring bit3 ,
+// INT1_1 length1 ,
+// octetstring octN optional }
+// with { variant (bit4) "FIELDLENGTH(4)" ;
+// variant (bit1) "FIELDLENGTH(1)" ;
+// variant (bit3) "FIELDLENGTH(3)" ;
+// variant (length1) "LENGTHTO(octN)" ;
+// };
+
+
+// type record Rec2_1
+// { bitstring bit8 ,
+// INT1_1 length1 ,
+// octetstring octN optional }
+// with { variant (bit8) "FIELDLENGTH(8)" ;
+// variant (length1) "LENGTHTO(octN)" ;
+// };
+
+
+// type record Rec3_2
+// { bitstring bit4 ,
+// bitstring bit1 ,
+// bitstring bit3 ,
+// integer int ,
+// octetstring oct2 optional }
+// with { variant (bit4) "FIELDLENGTH(4)" ;
+// variant (bit1) "FIELDLENGTH(1)" ;
+// variant (bit3) "FIELDLENGTH(3)" ;
+// variant (oct2) "FIELDLENGTH(2)" ;
+// };
+
+
+
+// type record Rec4
+// { integer int ,
+// octetstring oct5 optional }
+// with { variant (oct5) "FIELDLENGTH(5)" };
+
+
+// type union opt_par_union
+// { octetstring octstr ,
+// Rec2_1 rec2 ,
+// Rec3_2 rec3 ,
+// Rec4 rec4 }
+// with { variant (octstr) "FIELDLENGTH(2)" };
+
+
+// type record opt_par
+// { integer id ,
+// integer length1 ,
+// opt_par_union par }
+// with { variant (length1) "LENGTHTO(par)" ;
+// variant (par) "CROSSTAG(
+// octstr , id=1 ;
+// rec2 , id=2 ;
+// rec3 , id=3 ;
+// rec4 , id=4 ; )"
+// } ;
+
+
+
+
+// type set of opt_par optional_part
+// with { variant "" };
+
+
+// type record RAW_PDU
+// { pointer var_part_ptr,
+// pointer opt_part_ptr,
+// INT1_1 length1,
+// Rec1_1 rec1 optional,
+// optional_part opt_part optional,
+// end_of_optional_parameters_indicator EndOP optional
+// } with { variant (var_part_ptr) "POINTERTO (length1)";
+// variant (opt_part_ptr) "POINTERTO (opt_part)";
+// variant (length1) "LENGTHTO (rec1)" };
+//
+// }with{encode "RAW"}
+
+testcase TC_structured_types_5() runs on TempComp{
+ const RAW_PDU_154
+ i := { var_part_ptr := 2 ,
+ opt_part_ptr := 4 ,
+ length1 := 2 ,
+ rec1 := { bit4 := '1111'B , // rec1 := omit
+ bit1 := '1'B ,
+ bit3 := '000'B ,
+ length1 := 0 ,
+ octN := omit } ,
+ opt_part := { { id := 1 , // opt_part := omit
+ length1 := 2 ,
+ par := { octstr := 'FFFF'O } } ,
+ { id := 2 ,
+ length1 := 7 ,
+ par := { rec2:= { bit8 := '00000000'B ,
+ length1 := 5 ,
+ octN := '1234567890'O } } } , // octN := omit
+ { id := 3 ,
+ length1 := 4 ,
+ par := { rec3 := { bit4 := '1111'B ,
+ bit1 := '0'B ,
+ bit3 := '100'B ,
+ int := 15 ,
+ oct2 := '1234'O } } } , // oct2 := omit
+ { id := 4 ,
+ length1 := 6 ,
+ par := { rec4:= { int := 15 ,
+ oct5 := '1234567890'O } } } } , // oct5 := omit
+ EndOP := '00'O } // EndOP = omit
+
+
+
+ const octetstring o := '0204021F000102FFFF02070005123456789003048F0F123404060F123456789000'O
+
+
+ if ((enc_RAW_PDU_154(i) == o)and(dec_RAW_PDU_154(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_154(i)= ", enc_RAW_PDU_154(i), "; dec_RAW_PDU_154(o)= ", dec_RAW_PDU_154(o));}
+}
+
+//==================================
+// Test of structured types - 6
+//==================================
+
+testcase TC_structured_types_6() runs on TempComp{
+
+ const RAW_PDU_154
+ i := { var_part_ptr := 2 ,
+ opt_part_ptr := 2 ,
+ length1 := 0 ,
+ rec1 := omit ,
+ opt_part := { { id := 1 , // opt_part := omit
+ length1 := 2 ,
+ par := { octstr := 'FFFF'O } } ,
+ { id := 2 ,
+ length1 := 7 ,
+ par := { rec2:= { bit8 := '00000000'B ,
+ length1 := 5 ,
+ octN := '1234567890'O } } } , // octN := omit
+ { id := 3 ,
+ length1 := 4 ,
+ par := { rec3 := { bit4 := '1111'B ,
+ bit1 := '0'B ,
+ bit3 := '100'B ,
+ int := 15 ,
+ oct2 := '1234'O } } } , // oct2 := omit
+ { id := 4 ,
+ length1 := 6 ,
+ par := { rec4:= { int := 15 ,
+ oct5 := '1234567890'O } } } } , // oct5 := omit
+ EndOP := '00'O } // EndOP = omit
+
+
+
+ const octetstring o := '0202000102FFFF02070005123456789003048F0F123404060F123456789000'O
+
+ if ((enc_RAW_PDU_154(i) == o)and(dec_RAW_PDU_154(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_154(i)= ", enc_RAW_PDU_154(i), "; dec_RAW_PDU_154(o)= ", dec_RAW_PDU_154(o));}
+}
+//==================================
+// Test of structured types - 7
+//==================================
+
+testcase TC_structured_types_7() runs on TempComp{
+
+ const RAW_PDU_154
+ i := { var_part_ptr := 2 ,
+ opt_part_ptr := 2 ,
+ length1 := 0 ,
+ rec1 := omit ,
+ opt_part := { { id := 1 , // opt_part := omit
+ length1 := 2 ,
+ par := { octstr := 'FFFF'O } } ,
+ { id := 2 ,
+ length1 := 2 ,
+ par := { rec2:= { bit8 := '00000000'B ,
+ length1 := 0 ,
+ octN := omit } } } ,
+ { id := 3 ,
+ length1 := 2 ,
+ par := { rec3 := { bit4 := '1111'B ,
+ bit1 := '0'B ,
+ bit3 := '100'B ,
+ int := 15 ,
+ oct2 := omit } } } ,
+ { id := 4 ,
+ length1 := 1 ,
+ par := { rec4:= { int := 15 ,
+ oct5 := omit } } } } ,
+ EndOP := '00'O } // EndOP = omit
+
+
+
+ const octetstring o := '0202000102FFFF0202000003028F0F04010F00'O
+
+ if ((enc_RAW_PDU_154(i) == o)and(dec_RAW_PDU_154(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_154(i)= ", enc_RAW_PDU_154(i), "; dec_RAW_PDU_154(o)= ", dec_RAW_PDU_154(o));}
+
+}
+//==================================
+// Test of structured types - 8
+//==================================
+
+testcase TC_structured_types_8() runs on TempComp{
+
+ const RAW_PDU_154
+ i := { var_part_ptr := 2 ,
+ opt_part_ptr := 0 ,
+ length1 := 0 ,
+ rec1 := omit ,
+ opt_part := omit ,
+ EndOP := '00'O } // EndOP = omit
+
+ const octetstring o := '02000000'O
+ if ((enc_RAW_PDU_154(i) == o)and(dec_RAW_PDU_154(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_154(i)= ", enc_RAW_PDU_154(i), "; dec_RAW_PDU_154(o)= ", dec_RAW_PDU_154(o));}
+
+}
+
+//==================================
+// Test of structured types - 9
+//==================================
+
+testcase TC_structured_types_9() runs on TempComp{
+
+ const RAW_PDU_154
+ i := { var_part_ptr := 2 ,
+ opt_part_ptr := 0 ,
+ length1 := 0 ,
+ rec1 := omit ,
+ opt_part := omit ,
+ EndOP := omit }
+
+
+
+ const octetstring o := '020000'O
+ if ((enc_RAW_PDU_154(i) == o)and(dec_RAW_PDU_154(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_154(i)= ", enc_RAW_PDU_154(i), "; dec_RAW_PDU_154(o)= ", dec_RAW_PDU_154(o));}
+
+}
+
+
+//==================================
+// Test of structured types - 10
+//==================================
+
+
+group RAW_group32{
+
+type integer Pointer2
+with { variant "" } ;
+
+type octetstring EndOfOptionalPart
+with { variant "FIELDLENGTH(1)" } ;
+
+// type integer INT1_1
+// with { variant "" } ;
+
+// type bitstring BIT1_
+// with { variant "FIELDLENGTH(1)" } ;
+//
+// type bitstring BIT7_
+// with { variant "FIELDLENGTH(7)" } ;
+//
+// type octetstring OCT3_
+// with { variant "FIELDLENGTH(3)" } ;
+
+type hexstring HEX2
+with { variant "FIELDLENGTH(2)" } ;
+
+type enumerated MessageType
+ { e1(1), e2(2), e3(3), e4(4), e5(5) }
+ with { variant "FIELDLENGTH(8)" }
+
+
+type enumerated ParamName
+ { name1(1), name2(2), name3(3), name4(4) }
+ with { variant "FIELDLENGTH(8)" }
+
+type record Param1
+{ ParamName paramName ,
+ integer paramLength ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int }
+with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
+
+type record Param2
+{ ParamName paramName ,
+ integer paramLength ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int }
+with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
+
+type record Param3
+{ ParamName paramName ,
+ integer paramLength ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int }
+with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
+
+type record Param4
+{ ParamName paramName ,
+ integer paramLength ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int }
+with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
+
+type set Optional_part2
+{ Param1 param1 optional ,
+ Param2 param2 optional ,
+ Param3 param3 optional ,
+ Param4 param4 optional }
+ with { variant "TAG (
+ param1 , paramName= name1;
+ param2 , paramName= name2;
+ param3 , paramName= name3;
+ param4 , paramName= name4 )" }
+
+
+
+type record Elem1
+{ MessageType messageType ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int ,
+ Pointer2 pointer1 ,
+ Pointer2 pointer2 ,
+ integer length1 ,
+ octetstring octN ,
+ Optional_part2 opt_part ,
+ EndOfOptionalPart eop optional }
+ with { variant (pointer1) "POINTERTO(length1)";
+ variant (pointer2) "POINTERTO(opt_part)" ;
+ variant (length1) "LENGTHTO(octN)"
+
+ //Note, that optional part itself is mandatory but it may be empty!
+ }
+
+
+type record Elem2
+{ MessageType messageType ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int ,
+ Pointer2 pointer1 ,
+ Pointer2 pointer2 ,
+ integer length1 ,
+ octetstring octN ,
+ Optional_part2 opt_part ,
+ EndOfOptionalPart eop optional }
+ with { variant (pointer1) "POINTERTO(length1)";
+ variant (pointer2) "POINTERTO(opt_part)" ;
+ variant (length1) "LENGTHTO(octN)"
+
+ //Note, that optional part itself is mandatory but it may be empty!
+ }
+
+
+type record Elem3
+{ MessageType messageType ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int ,
+ Pointer2 pointer1 ,
+ Pointer2 pointer2 ,
+ integer length1 ,
+ octetstring octN ,
+ Optional_part2 opt_part ,
+ EndOfOptionalPart eop optional }
+ with { variant (pointer1) "POINTERTO(length1)";
+ variant (pointer2) "POINTERTO(opt_part)" ;
+ variant (length1) "LENGTHTO(octN)"
+
+ //Note, that optional part itself is mandatory but it may be empty!
+ }
+
+
+type record Elem4
+{ MessageType messageType ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int ,
+ Pointer2 pointer1 ,
+ Pointer2 pointer2 ,
+ integer length1 ,
+ octetstring octN ,
+ Optional_part2 opt_part ,
+ EndOfOptionalPart eop optional }
+ with { variant (pointer1) "POINTERTO(length1)";
+ variant (pointer2) "POINTERTO(opt_part)" ;
+ variant (length1) "LENGTHTO(octN)"
+
+ //Note, that optional part itself is mandatory but it may be empty!
+ }
+
+
+type record Elem5
+{ MessageType messageType ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int ,
+ Pointer2 pointer1 ,
+ Pointer2 pointer2 ,
+ integer length1 ,
+ octetstring octN ,
+ Optional_part2 opt_part ,
+ EndOfOptionalPart eop optional }
+ with { variant (pointer1) "POINTERTO(length1)";
+ variant (pointer2) "POINTERTO(opt_part)" ;
+ variant (length1) "LENGTHTO(octN)"
+
+ //Note, that optional part itself is mandatory but it may be empty!
+ }
+
+
+type union RAW_PDU_155
+{ Elem1 elem1 ,
+ Elem2 elem2 ,
+ Elem3 elem3 ,
+ Elem4 elem4 ,
+ Elem5 elem5 }
+with { variant "TAG (
+ elem1 , messageType = e1 ;
+ elem2 , messageType = e2 ;
+ elem3 , messageType = e3 ;
+ elem4 , messageType = e4 ;
+ elem5 , messageType = e5 ) "
+ } ;
+
+}with{encode "RAW"}
+
+
+external function enc_RAW_PDU_155(in RAW_PDU_155 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_155(in octetstring stream) return RAW_PDU_155 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_structured_types_10() runs on TempComp{
+ const RAW_PDU_155
+ i := { elem1 :=
+ { messageType := e1 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 ,
+ pointer1 := 2 ,
+ pointer2 := 7 ,
+ length1 := 5 ,
+ octN := '1234567890'O ,
+ opt_part :=
+ { param1 :=
+ { paramName := name1 ,
+ paramLength := 6 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 } ,
+ param4 :=
+ { paramName := name4 ,
+ paramLength := 6 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 } ,
+ param3 :=
+ { paramName := name3 ,
+ paramLength := 6 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 } ,
+ param2 :=
+ { paramName := name2 ,
+ paramLength := 6 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 } },
+ eop := '00'O } }
+
+
+
+ const octetstring o := '0112345680FF010207051234567890010612345680FF01020612345680FF01030612345680FF01040612345680FF0100'O
+
+ if ((enc_RAW_PDU_155(i) == o)and(dec_RAW_PDU_155(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_155(i)= ", enc_RAW_PDU_155(i), "; dec_RAW_PDU_155(o)= ", dec_RAW_PDU_155(o));}
+}
+
+//=======================================
+// Test of structured types - 11
+//=======================================
+testcase TC_structured_types_11() runs on TempComp{
+ const RAW_PDU_155
+ i := { elem1 :=
+ { messageType := e1 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 ,
+ pointer1 := 2 ,
+ pointer2 := 7 ,
+ length1 := 5 ,
+ octN := '1234567890'O ,
+ opt_part :=
+ { param1 := omit ,
+ param4 := omit ,
+ param3 := omit ,
+ param2 := omit },
+ eop := omit } }
+
+ const octetstring o := '0112345680FF010207051234567890'O
+
+ if ((enc_RAW_PDU_155(i) == o)and(dec_RAW_PDU_155(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_155(i)= ", enc_RAW_PDU_155(i), "; dec_RAW_PDU_155(o)= ", dec_RAW_PDU_155(o));}
+}
+
+//=======================================
+// Test of structured types - 12
+//=======================================
+testcase TC_structured_types_12() runs on TempComp{
+ const RAW_PDU_155
+ i := { elem1 :=
+ { messageType := e1 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 ,
+ pointer1 := 2 ,
+ pointer2 := 7 ,
+ length1 := 5 ,
+ octN := '1234567890'O ,
+ opt_part :=
+ { param1 :=
+ { paramName := name1 ,
+ paramLength := 6 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 } ,
+ param4 :=
+ { paramName := name4 ,
+ paramLength := 6 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 } ,
+ param3 :=
+ { paramName := name3 ,
+ paramLength := 6 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 } ,
+ param2 := omit },
+ eop := '00'O } }
+
+
+
+ const octetstring o := '0112345680FF010207051234567890010612345680FF01030612345680FF01040612345680FF0100'O
+
+
+ if ((enc_RAW_PDU_155(i) == o)and(dec_RAW_PDU_155(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_155(i)= ", enc_RAW_PDU_155(i), "; dec_RAW_PDU_155(o)= ", dec_RAW_PDU_155(o));}
+}
+
+//=======================================
+// Test of structured types - 13
+//=======================================
+testcase TC_structured_types_13() runs on TempComp{
+ const RAW_PDU_155
+ i := { elem2 :=
+ { messageType := e2 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 ,
+ pointer1 := 2 ,
+ pointer2 := 7 ,
+ length1 := 5 ,
+ octN := '1234567890'O ,
+ opt_part :=
+ { param1 :=
+ { paramName := name1 ,
+ paramLength := 6 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 } ,
+ param4 := omit ,
+ param3 :=
+ { paramName := name3 ,
+ paramLength := 6 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 } ,
+ param2 := omit },
+ eop := omit } }
+
+
+
+ const octetstring o := '0212345680FF010207051234567890010612345680FF01030612345680FF01'O
+
+ if ((enc_RAW_PDU_155(i) == o)and(dec_RAW_PDU_155(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_155(i)= ", enc_RAW_PDU_155(i), "; dec_RAW_PDU_155(o)= ", dec_RAW_PDU_155(o));}
+}
+
+//=======================================
+// Test of structured types - 14
+//=======================================
+
+
+group RAW_group33{
+
+// type integer Pointer
+// with { variant "" } ;
+//
+// type octetstring EndOfOptionalPart
+// with { variant "FIELDLENGTH(1)" } ;
+//
+// type integer INT1
+// with { variant "" } ;
+//
+// type bitstring BIT1
+// with { variant "FIELDLENGTH(1)" } ;
+//
+// type bitstring BIT7
+// with { variant "FIELDLENGTH(7)" } ;
+//
+// type octetstring OCT3
+// with { variant "FIELDLENGTH(3)" } ;
+//
+// type hexstring HEX2
+// with { variant "FIELDLENGTH(2)" } ;
+
+// type enumerated MessageType
+// { e1(1), e2(2), e3(3), e4(4), e5(5) }
+// with { variant "FIELDLENGTH(8)" }
+
+
+// type enumerated ParamName
+// { name1(1), name2(2), name3(3), name4(4) }
+// with { variant "FIELDLENGTH(8)" }
+
+// type record Param1
+// { ParamName paramName ,
+// integer paramLength ,
+// OCT3_ octstr ,
+// BIT7_ bit7 ,
+// BIT1_ bit1 ,
+// HEX2 hexstr ,
+// INT1_1 int }
+// with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
+//
+// type record Param2
+// { ParamName paramName ,
+// integer paramLength ,
+// OCT3 octstr ,
+// BIT7 bit7 ,
+// BIT1 bit1 ,
+// HEX2 hexstr ,
+// INT1 int }
+// with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
+//
+// type record Param3
+// { ParamName paramName ,
+// integer paramLength ,
+// OCT3 octstr ,
+// BIT7 bit7 ,
+// BIT1 bit1 ,
+// HEX2 hexstr ,
+// INT1 int }
+// with {variant (paramLength) "LENGTHTO(octstr , bit7 , bit1 , hexstr , int )" }
+
+
+type record Field1
+{ BIT1_ field2indic ,
+ BIT7_ field2par }
+with { variant "" }
+
+
+
+type union Field2
+{ OCT3 present_ ,
+ OCT3 absent }
+with { variant "" }
+
+
+
+type record Param4_1
+{ ParamName paramName ,
+ integer paramLength ,
+ Field1 field1 ,
+ Field2 field2 ,
+ HEX2 hexstr ,
+ INT1_1 int }
+ with { variant (field2) "CROSSTAG(
+ present_ , field1.field2indic = '1'B ;
+ absent , field1.field2indic = '0'B ; )" ;
+ variant (paramLength) "LENGTHTO(field1 , field2 , hexstr , int )" }
+
+type set Optional_part_1
+{ Param1 param1 optional ,
+ Param2 param2 optional ,
+ Param3 param3 optional ,
+ Param4_1 param4 optional }
+ with { variant "TAG (
+ param1 , paramName= name1;
+ param2 , paramName= name2;
+ param3 , paramName= name3;
+ param4 , paramName= name4 )" }
+
+
+type record Elem1_1
+{ MessageType messageType ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int ,
+ Pointer2 pointer1 ,
+ Pointer2 pointer2 ,
+ integer length1 ,
+ octetstring octN ,
+ Optional_part_1 opt_part ,
+ EndOfOptionalPart eop optional }
+ with { variant (pointer1) "POINTERTO(length1)";
+ variant (pointer2) "POINTERTO(opt_part)" ;
+ variant (length1) "LENGTHTO(octN)"
+
+ //Note, that optional part itself is mandatory but it may be empty!
+ }
+
+
+type record Elem2_1
+{ MessageType messageType ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int ,
+ Pointer2 pointer1 ,
+ Pointer2 pointer2 ,
+ integer length1 ,
+ octetstring octN ,
+ Optional_part_1 opt_part ,
+ EndOfOptionalPart eop optional }
+ with { variant (pointer1) "POINTERTO(length1)";
+ variant (pointer2) "POINTERTO(opt_part)" ;
+ variant (length1) "LENGTHTO(octN)"
+
+ //Note, that optional part itself is mandatory but it may be empty!
+ }
+
+
+type record Elem3_1
+{ MessageType messageType ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int ,
+ Pointer2 pointer1 ,
+ Pointer2 pointer2 ,
+ integer length1 ,
+ octetstring octN ,
+ Optional_part_1 opt_part ,
+ EndOfOptionalPart eop optional }
+ with { variant (pointer1) "POINTERTO(length1)";
+ variant (pointer2) "POINTERTO(opt_part)" ;
+ variant (length1) "LENGTHTO(octN)"
+
+ //Note, that optional part itself is mandatory but it may be empty!
+ }
+
+
+type record Elem4_1
+{ MessageType messageType ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int ,
+ Pointer2 pointer1 ,
+ Pointer2 pointer2 ,
+ integer length1 ,
+ octetstring octN ,
+ Optional_part2 opt_part ,
+ EndOfOptionalPart eop optional }
+ with { variant (pointer1) "POINTERTO(length1)";
+ variant (pointer2) "POINTERTO(opt_part)" ;
+ variant (length1) "LENGTHTO(octN)"
+
+ //Note, that optional part itself is mandatory but it may be empty!
+ }
+
+
+type record Elem5_1
+{ MessageType messageType ,
+ OCT3_ octstr ,
+ BIT7_ bit7 ,
+ BIT1_ bit1 ,
+ HEX2 hexstr ,
+ INT1_1 int ,
+ Pointer2 pointer1 ,
+ Pointer2 pointer2 ,
+ integer length1 ,
+ octetstring octN ,
+ Optional_part2 opt_part ,
+ EndOfOptionalPart eop optional }
+ with { variant (pointer1) "POINTERTO(length1)";
+ variant (pointer2) "POINTERTO(opt_part)" ;
+ variant (length1) "LENGTHTO(octN)"
+
+ //Note, that optional part itself is mandatory but it may be empty!
+ }
+
+
+type union RAW_PDU_156
+{ Elem1_1 elem1 ,
+ Elem2_1 elem2 ,
+ Elem3_1 elem3 ,
+ Elem4_1 elem4 ,
+ Elem5_1 elem5 }
+with { variant "TAG (
+ elem1 , messageType = e1 ;
+ elem2 , messageType = e2 ;
+ elem3 , messageType = e3 ;
+ elem4 , messageType = e4 ;
+ elem5 , messageType = e5 ) "
+ } ;
+
+} with{encode "RAW"}
+
+external function enc_RAW_PDU_156(in RAW_PDU_156 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_156(in octetstring stream) return RAW_PDU_156 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_structured_types_14() runs on TempComp{
+ const RAW_PDU_156
+ i := { elem2 :=
+ { messageType := e2 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 ,
+ pointer1 := 2 ,
+ pointer2 := 7 ,
+ length1 := 5 ,
+ octN := '1234567890'O ,
+ opt_part :=
+ { param1 :=
+ { paramName := name1 ,
+ paramLength := 6 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 } ,
+ param4 :=
+ { paramName := name4 ,
+ paramLength := 6 ,
+ field1 :=
+ { field2indic := '1'B ,
+ field2par := '0000000'B } ,
+ field2 :=
+ { present_ := 'FFFFFF'O } ,
+ hexstr := '12'H ,
+ int := 1 } ,
+ param3 :=
+ { paramName := name3 ,
+ paramLength := 6 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 } ,
+ param2 := omit },
+ eop := '00'O } }
+
+ const octetstring o :='0212345680FF010207051234567890010612345680FF01030612345680FF01040601FFFFFF210100'O
+ if ((enc_RAW_PDU_156(i) == o)and(dec_RAW_PDU_156(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_156(i)= ", enc_RAW_PDU_156(i), "; dec_RAW_PDU_156(o)= ", dec_RAW_PDU_156(o));}
+}
+
+// Test of structured types - 15
+
+testcase TC_structured_types_15() runs on TempComp{
+ const RAW_PDU_156
+ i := { elem2 :=
+ { messageType := e2 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 ,
+ pointer1 := 2 ,
+ pointer2 := 7 ,
+ length1 := 5 ,
+ octN := '1234567890'O ,
+ opt_part :=
+ { param1 :=
+ { paramName := name1 ,
+ paramLength := 6 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 } ,
+ param4 :=
+ { paramName := name4 ,
+ paramLength := 6 ,
+ field1 :=
+ { field2indic := '0'B ,
+ field2par := '0000000'B } ,
+ field2 :=
+ { absent := '000000'O } ,
+ hexstr := '12'H ,
+ int := 1 } ,
+ param3 :=
+ { paramName := name3 ,
+ paramLength := 6 ,
+ octstr := '123456'O ,
+ bit7 := '0000000'B ,
+ bit1 := '1'B ,
+ hexstr := 'FF'H ,
+ int := 1 } ,
+ param2 := omit },
+ eop := '00'O } }
+
+
+
+ const octetstring o :='0212345680FF010207051234567890010612345680FF01030612345680FF01040600000000210100'O
+
+
+ if ((enc_RAW_PDU_156(i) == o)and(dec_RAW_PDU_156(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_156(i)= ", enc_RAW_PDU_156(i), "; dec_RAW_PDU_156(o)= ", dec_RAW_PDU_156(o));}
+}
+
+//=================================
+// Test of structured types - 16
+//=================================
+
+group RAW_group34{
+
+type bitstring BIT4_
+with { variant "FIELDLENGTH(4)" } ;
+
+type octetstring OCT2_
+with { variant "FIELDLENGTH(2)" } ;
+
+// type octetstring OCT3_
+// with { variant "FIELDLENGTH(3)" } ;
+
+type union Union2
+{ OCT3_ field1 ,
+ OCT2_ field2 ,
+ OCT3_ field3 ,
+ OCT2_ field4 }
+ with { variant ""};
+
+
+type union Union1
+{ BIT4_ field1 ,
+ BIT4_ field2 }
+ with { variant ""};
+
+
+type record RAW_PDU_157
+{ BIT4_ id ,
+ Union1 union1 ,
+ Union2 union2 }
+ with { variant (union2) "CROSSTAG(
+ field1 , id = '0001'B ;
+ field2 , id = '0010'B ;
+ field3 , id = '0011'B ;
+ field4 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B } )" ;
+ variant (union1) "CROSSTAG(
+ field1 , { id = '0001'B ,
+ id = '0010'B ,
+ id = '0011'B } ;
+ field2 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B } )" } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_157(in RAW_PDU_157 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_157(in octetstring stream) return RAW_PDU_157 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_structured_types_16() runs on TempComp{
+ const RAW_PDU_157
+ i := { id := '0001'B ,
+ union1 := { field1 := '0000'B } ,
+ union2 := { field1 := '123456'O } }
+
+
+
+ const octetstring o :='01123456'O
+
+ if ((enc_RAW_PDU_157(i) == o)and(dec_RAW_PDU_157(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_157(i)= ", enc_RAW_PDU_157(i), "; dec_RAW_PDU_157(o)= ", dec_RAW_PDU_157(o));}
+}
+
+//=================================
+// Test of structured types - 17
+//=================================
+testcase TC_structured_types_17() runs on TempComp{
+ const RAW_PDU_157
+ i := { id := '0111'B ,
+ union1 := { field2 := '1111'B } ,
+ union2 := { field4 := '1234'O } }
+
+
+
+ const octetstring o :='F71234'O
+
+ if ((enc_RAW_PDU_157(i) == o)and(dec_RAW_PDU_157(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_157(i)= ", enc_RAW_PDU_157(i), "; dec_RAW_PDU_157(o)= ", dec_RAW_PDU_157(o));}
+}
+
+//===========================================================
+// Testing RAW update
+//===========================================================
+
+//=================================
+// Raw update test 1
+//=================================
+
+
+group RAW_group35{
+
+// type bitstring BIT4
+// with { variant "FIELDLENGTH(4)" } ;
+//
+// type octetstring OCT2
+// with { variant "FIELDLENGTH(2)" } ;
+
+type union Union2_1
+{ OCT2_ field1 ,
+ OCT2_ field2 ,
+ OCT2_ field3 ,
+ OCT2_ field4 }
+ with { variant ""};
+
+
+// type union Union1
+// { BIT4_ field1 ,
+// BIT4_ field2 }
+// with { variant ""};
+
+
+type record RAW_PDU_158
+{ Union2_1 union2 ,
+ Union1 union1,
+ BIT4_ id }
+ with { variant (union2) "CROSSTAG(
+ field1 , id = '0001'B ;
+ field2 , id = '0010'B ;
+ field3 , id = '0011'B ;
+ field4 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B } )" ;
+ variant (union1) "CROSSTAG(
+ field1 , { id = '0001'B ,
+ id = '0010'B ,
+ id = '0011'B } ;
+ field2 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B } )" } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_158(in RAW_PDU_158 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_158(in octetstring stream) return RAW_PDU_158 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Raw_update_test_1() runs on TempComp{
+ const RAW_PDU_158
+ i := { union2 := { field4 := '1234'O } ,
+ union1 := { field2 := '1111'B },
+ id := '0111'B }
+
+ const octetstring o :='12347F'O
+
+ if ((enc_RAW_PDU_158(i) == o )and(dec_RAW_PDU_158(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_158(i)= ", enc_RAW_PDU_158(i), "; dec_RAW_PDU_158(o)= ", dec_RAW_PDU_158(o));}
+}
+
+//=================================
+// Raw update test 2
+//=================================
+testcase TC_Raw_update_test_2() runs on TempComp{
+ const RAW_PDU_158
+ i := { union2 := { field1 := '1234'O } ,
+ union1 := { field1 := '1111'B },
+ id := '0001'B }
+
+ const octetstring o :='12341F'O
+
+ if ((enc_RAW_PDU_158(i) == o )and(dec_RAW_PDU_158(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_158(i)= ", enc_RAW_PDU_158(i), "; dec_RAW_PDU_158(o)= ", dec_RAW_PDU_158(o));}
+}
+
+//=================================
+// Raw update test 3
+//=================================
+group RAW_group36{
+
+type bitstring BIT8
+with { variant "FIELDLENGTH(8)"};
+
+type record RAW_PDU_159
+{ Union2_1 union2 ,
+ Union1 union1,
+ BIT8 outfiller,
+ BIT4_ id }
+ with { variant (union2) "CROSSTAG(
+ field1 , id = '0001'B ;
+ field2 , id = '0010'B ;
+ field3 , id = '0011'B ;
+ field4 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B } )" ;
+ variant (union1) "CROSSTAG(
+ field1 , { id = '0001'B ,
+ id = '0010'B ,
+ id = '0011'B } ;
+ field2 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B } )" } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_159(in RAW_PDU_159 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_159(in octetstring stream) return RAW_PDU_159 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Raw_update_test_3() runs on TempComp{
+
+ const RAW_PDU_159
+ i := { union2 := { field1 := '1234'O } ,
+ union1 := { field1 := '1111'B },
+ outfiller := '00001000'B,
+ id := '0001'B }
+
+ const octetstring o :='12348F10'O
+
+ if ((enc_RAW_PDU_159(i) == o )and(dec_RAW_PDU_159(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_159(i)= ", enc_RAW_PDU_159(i), "; dec_RAW_PDU_159(o)= ", dec_RAW_PDU_159(o));}
+}
+//=================================
+// Raw update test 4
+//=================================
+group RAW_group37{
+
+type record RAW_PDU_160
+{ Union2_1 union2 ,
+ BIT8 outfiller,
+ Union1 union1,
+ BIT4_ id }
+ with { variant (union2) "CROSSTAG(
+ field1 , id = '0001'B ;
+ field2 , id = '0010'B ;
+ field3 , id = '0011'B ;
+ field4 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B } )" ;
+ variant (union1) "CROSSTAG(
+ field1 , { id = '0001'B ,
+ id = '0010'B ,
+ id = '0011'B } ;
+ field2 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B } )" } ;
+
+}with{encode "RAW"}
+
+
+external function enc_RAW_PDU_160(in RAW_PDU_160 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_160(in octetstring stream) return RAW_PDU_160 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Raw_update_test_4() runs on TempComp{
+
+ const RAW_PDU_160
+ i := { union2 := { field1 := '1234'O } ,
+ outfiller := '00001000'B,
+ union1 := { field1 := '1111'B },
+ id := '0001'B }
+
+
+ const octetstring o :='1234081F'O
+
+ if ((enc_RAW_PDU_160(i) == o )and(dec_RAW_PDU_160(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_160(i)= ", enc_RAW_PDU_160(i), "; dec_RAW_PDU_160(o)= ", dec_RAW_PDU_160(o));}
+}
+//=================================
+// Raw update test 5
+//=================================
+group RAW_group38{
+
+type record RAW_PDU_161
+{ BIT8 outfiller,
+ Union2_1 union2 ,
+ Union1 union1,
+ BIT4_ id }
+ with { variant (union2) "CROSSTAG(
+ field1 , id = '0001'B ;
+ field2 , id = '0010'B ;
+ field3 , id = '0011'B ;
+ field4 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B } )" ;
+ variant (union1) "CROSSTAG(
+ field1 , { id = '0001'B ,
+ id = '0010'B ,
+ id = '0011'B } ;
+ field2 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B } )" } ;
+
+}with{encode "RAW"}
+
+
+external function enc_RAW_PDU_161(in RAW_PDU_161 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_161(in octetstring stream) return RAW_PDU_161 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Raw_update_test_5() runs on TempComp{
+
+ const RAW_PDU_161
+ i := { outfiller := '00001000'B,
+ union2 := { field1 := '1234'O } ,
+ union1 := { field1 := '1111'B },
+ id := '0001'B }
+
+
+ const octetstring o :='0812341F'O
+
+
+ if ((enc_RAW_PDU_161(i) == o )and(dec_RAW_PDU_161(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_161(i)= ", enc_RAW_PDU_161(i), "; dec_RAW_PDU_161(o)= ", dec_RAW_PDU_161(o));}
+}
+
+//=================================
+// Raw update test 6
+//=================================
+group RAW_group39{
+
+type record RAW_PDU_162
+{ Union2_1 union2 ,
+ BIT4_ id,
+ Union1 union1}
+ with { variant (union2) "CROSSTAG(
+ field1 , id = '0001'B ;
+ field2 , id = '0010'B ;
+ field3 , id = '0011'B ;
+ field4 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B } )" ;
+ variant (union1) "CROSSTAG(
+ field1 , { id = '0001'B ,
+ id = '0010'B ,
+ id = '0011'B } ;
+ field2 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B } )" } ;
+
+}with{encode "RAW"}
+
+
+external function enc_RAW_PDU_162(in RAW_PDU_162 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_162(in octetstring stream) return RAW_PDU_162 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Raw_update_test_6() runs on TempComp{
+
+ const RAW_PDU_162
+ i := { union2 := { field1 := '1234'O },
+ id := '0001'B,
+ union1 := { field1 := '1111'B }
+ }
+
+ const octetstring o :='1234F1'O
+
+
+ if ((enc_RAW_PDU_162(i) == o )and(dec_RAW_PDU_162(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_162(i)= ", enc_RAW_PDU_162(i), "; dec_RAW_PDU_162(o)= ", dec_RAW_PDU_162(o));}
+}
+
+//=================================
+// Raw update test 7
+//=================================
+testcase TC_Raw_update_test_7() runs on TempComp{
+
+ const RAW_PDU_162
+ i := { union2 := { field4 := '1234'O },
+ id := '0101'B,
+ union1 := { field2 := '1111'B }
+ }
+
+
+ const octetstring o :='1234F5'O
+
+
+ if ((enc_RAW_PDU_162(i) == o )and(dec_RAW_PDU_162(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_162(i)= ", enc_RAW_PDU_162(i), "; dec_RAW_PDU_162(o)= ", dec_RAW_PDU_162(o));}
+}
+
+//=================================
+// Raw update test 8
+//=================================
+
+
+group RAW_group40{
+
+
+type record RAW_PDU_163
+{ Union2_1 union2_1,
+ Union2_1 union2_2,
+ Union1 union1_1,
+ BIT4_ id,
+ Union1 union1_2,
+ BIT4_ id2}
+ with { variant (union2_1) "CROSSTAG(
+ field1 , id = '0001'B ;
+ field2 , id = '0010'B ;
+ field3 , id = '0011'B ;
+ field4 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B } )" ;
+ variant (union1_1) "CROSSTAG(
+ field1 , { id = '0001'B ,
+ id = '0010'B ,
+ id = '0011'B } ;
+ field2 , { id = '0100'B ,
+ id = '0101'B ,
+ id = '0111'B })" ;
+ variant (union2_2) "CROSSTAG(field1 , id2 = '0001'B ;
+ field2 , OTHERWISE)";
+ variant (union1_2) "CROSSTAG(field1 , id2 = '0001'B ;
+ field2 , OTHERWISE)" ;
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_163(in RAW_PDU_163 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_163(in octetstring stream) return RAW_PDU_163 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Raw_update_test_8() runs on TempComp{
+
+ const RAW_PDU_163
+ i := { union2_1 := {field1 := '1234'O },
+ union2_2 := { field1 := '1234'O},
+ union1_1 := { field1 := '1111'B },
+ id := '0001'B,
+ union1_2 := { field1 := '1111'B},
+ id2 := '0001'B
+ }
+
+
+ const octetstring o :='123412341F1F'O
+
+
+ if ((enc_RAW_PDU_163(i) == o )and(dec_RAW_PDU_163(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_163(i)= ", enc_RAW_PDU_163(i), "; dec_RAW_PDU_163(o)= ", dec_RAW_PDU_163(o));}
+}
+//=================================
+// Raw update test 9 (OTHERWISE)
+//=================================
+group RAW_group41{
+
+type union Union3
+{ BIT4_ field1,
+ OCT2_ field2
+} with { variant ""};
+
+
+type record RAW_PDU_164
+{ BIT4_ id,
+ Union3 union3,
+ Union1 union1,
+ BIT4_ id2}
+ with { variant (union1) "CROSSTAG(field1 , id2 = '0001'B ;
+ field2 , OTHERWISE)" ;
+ variant (union3) "CROSSTAG( field1, id = '0001'B;
+ field2, OTHERWISE)"
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_164(in RAW_PDU_164 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_164(in octetstring stream) return RAW_PDU_164 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Raw_update_test_9() runs on TempComp{
+
+ const RAW_PDU_164
+ i := { id := '0001'B,
+ union3 := {field1 := '1110'B},
+ union1 := { field1 := '1111'B},
+ id2 := '0001'B
+ }
+
+ const octetstring o :='E11F'O
+
+ if ((enc_RAW_PDU_164(i) == o )and(dec_RAW_PDU_164(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_164(i)= ", enc_RAW_PDU_164(i), "; dec_RAW_PDU_164(o)= ", dec_RAW_PDU_164(o));}
+}
+//=================================
+// Raw update test 10
+//=================================
+group RAW_group42{
+
+group shortening{
+
+type union Union2_2
+{ OCT2 field1 ,
+ OCT2 field2 };
+
+
+} with {variant ""}
+
+type record RAW_PDU_165
+{ Union2_2 union2,
+ BIT4_ id,
+ Union3 union3,
+ Union1 union1,
+ BIT4_ id2}
+ with { variant (union1) "CROSSTAG(field1 , id2 = '0001'B ;
+ field2 , OTHERWISE)" ;
+ variant (union3) "CROSSTAG( field1, id = '0001'B;
+ field2, OTHERWISE)";
+ variant (union2) "CROSSTAG(field1 , id2 = '0001'B ;
+ field2 , OTHERWISE)"} ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_165(in RAW_PDU_165 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_165(in octetstring stream) return RAW_PDU_165 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Raw_update_test_10() runs on TempComp{
+
+ const RAW_PDU_165
+ i := { union2 := {field1 := '1234'O},
+ id := '0001'B,
+ union3 := {field1 := '1110'B},
+ union1 := { field1 := '1111'B},
+ id2 := '0001'B
+ }
+
+
+ const octetstring o :='1234E11F'O
+
+ if ((enc_RAW_PDU_165(i) == o )and(dec_RAW_PDU_165(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_165(i)= ", enc_RAW_PDU_165(i), "; dec_RAW_PDU_165(o)= ", dec_RAW_PDU_165(o));}
+}
+//=================================
+// Raw update test 11
+//=================================
+
+group RAW_group43{
+
+type record RAW_PDU_166
+{ union {
+ octetstring field1,
+ octetstring field2
+ } union2,
+ BIT4_ id,
+ Union3 union3,
+ Union1 union1,
+ BIT4_ id2}
+ with { variant (union1) "CROSSTAG(field1 , id2 = '0001'B ;
+ field2 , OTHERWISE)" ;
+ variant (union3) "CROSSTAG( field1, id = '0001'B;
+ field2, OTHERWISE)";
+ variant (union2) "CROSSTAG(field1 , id2 = '0001'B ;
+ field2 , OTHERWISE)";
+ variant (union2.field1, union2.field2) "FIELDLENGTH(2)"
+ } ;
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_166(in RAW_PDU_166 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_166(in octetstring stream) return RAW_PDU_166 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Raw_update_test_11() runs on TempComp{
+ const RAW_PDU_166
+ i := { union2 := {field1 := '1234'O},
+ id := '0001'B,
+ union3 := {field1 := '1110'B},
+ union1 := { field1 := '1111'B},
+ id2 := '0001'B
+ }
+
+
+ const octetstring o :='1234E11F'O
+
+ if ((enc_RAW_PDU_166(i) == o )and(dec_RAW_PDU_166(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_166(i)= ", enc_RAW_PDU_166(i), "; dec_RAW_PDU_166(o)= ", dec_RAW_PDU_166(o));}
+}
+
+//=================================
+// Raw update test 12
+//=================================
+
+group RAW_group44{
+
+type union Code {
+ integer field1,
+ integer field2,
+ integer field3
+} with { variant "FIELDLENGTH(8)"};
+
+type record RAW_PDU_167{
+ Code code,
+ bitstring ABCxxxxx,
+ integer PDU_length,
+ octetstring id optional
+} with { variant (PDU_length) "FIELDLENGTH(16)";
+ variant (ABCxxxxx) "FIELDLENGTH(8)";
+ variant (id) "PRESENCE( {
+ ABCxxxxx = '10000000'B,
+ ABCxxxxx = '10100000'B} )";
+ variant (code) "CROSSTAG(
+ field1, id = omit;
+ field2, id = '02'O;
+ field3, id = '03'O; )"};
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_167(in RAW_PDU_167 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_167(in octetstring stream) return RAW_PDU_167 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Raw_update_test_12() runs on TempComp{
+ const RAW_PDU_167
+ i := { code := { field1 := 16},
+ ABCxxxxx := '00000000'B,
+ PDU_length := 16,
+ id := omit }
+
+ const octetstring o :='10001000'O
+
+ if ((enc_RAW_PDU_167(i) == o )and(dec_RAW_PDU_167(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_167(i)= ", enc_RAW_PDU_167(i), "; dec_RAW_PDU_167(o)= ", dec_RAW_PDU_167(o));}
+}
+
+//=================================
+// Raw update test 13
+//=================================
+
+testcase TC_Raw_update_test_13() runs on TempComp{
+ const RAW_PDU_167
+ i := { code := { field2 := 16},
+ ABCxxxxx := '10000000'B,
+ PDU_length := 16,
+ id := '02'O }
+
+
+ const octetstring o :='1080100002'O
+
+ if ((enc_RAW_PDU_167(i) == o )and(dec_RAW_PDU_167(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_167(i)= ", enc_RAW_PDU_167(i), "; dec_RAW_PDU_167(o)= ", dec_RAW_PDU_167(o));}
+}
+
+//=================================
+// Raw update test 14
+//=================================
+
+group RAW_group45{
+
+type union Code_1 {
+ enumerated {e1a (0), e1b (1), e1c (2)} E1,
+ enumerated {e2a (1), e2b (2), e2c (3)} E2,
+ enumerated {e3a (2), e3b (3), e3c (4), e3d (5)} E3
+} with { variant (E1,E2,E3) "FIELDLENGTH(32)";
+ variant (E1,E2,E3) "BYTEORDER(last)";
+ variant (E1,E2,E3) "COMP(2scompl)"};
+
+type integer UINT24 (0..16777215)
+with {variant "FIELDLENGTH(24)";
+ variant "BYTEORDER(last)"};
+
+type enumerated Identifier {
+ id_E1 (0),
+ id_E2 (1),
+ id_E3 (2)
+} with {variant "FIELDLENGTH(32)";
+ variant "BYTEORDER(last)";
+ variant "COMP(2scompl)"};
+
+type record RAW_PDU_168{
+ Code_1 code,
+ bitstring ABCxxxxx,
+ UINT24 PDU_length,
+ Identifier id optional,
+ octetstring payload optional
+ } with { variant (ABCxxxxx) "FIELDLENGTH(8)";
+ variant (id) "PRESENCE( {
+ ABCxxxxx = '10000000'B,
+ ABCxxxxx = '10100000'B} )";
+ variant (code) "CROSSTAG(
+ E1, id = omit;
+ E2, id = id_E2;
+ E3, id = id_E3; )";
+ variant (PDU_length) "LENGTHTO(code,ABCxxxxx,PDU_length,id,payload)"};
+
+}with{encode "RAW"}
+
+external function enc_RAW_PDU_168(in RAW_PDU_168 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_168(in octetstring stream) return RAW_PDU_168 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_Raw_update_test_14() runs on TempComp{
+ const RAW_PDU_168
+ i := { code := {E1 := e1c},
+ ABCxxxxx := '00000000'B,
+ PDU_length := 8,
+ id := omit,
+ payload := omit}
+
+
+ const octetstring o :='0000000200000008'O ;
+
+ if ((enc_RAW_PDU_168(i) == o )and(dec_RAW_PDU_168(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_168(i)= ", enc_RAW_PDU_168(i), "; dec_RAW_PDU_168(o)= ", dec_RAW_PDU_168(o));}
+
+}
+
+//=================================
+// Raw update test 15
+//=================================
+
+testcase TC_Raw_update_test_15() runs on TempComp{
+ const RAW_PDU_168
+ i := { code := {E2 := e2b},
+ ABCxxxxx := '10000000'B,
+ PDU_length := 14,
+ id := id_E2,
+ payload := 'ABCD'O}
+
+ const octetstring o :='000000028000000E00000001ABCD'O ;
+
+ if ((enc_RAW_PDU_168(i) == o )and(dec_RAW_PDU_168(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_168(i)= ", enc_RAW_PDU_168(i), "; dec_RAW_PDU_168(o)= ", dec_RAW_PDU_168(o));}
+}
+
+//=================================
+// Raw update test 16
+//=================================
+
+testcase TC_Raw_update_test_16() runs on TempComp{
+ const RAW_PDU_168
+ i := { code := {E3 := e3b},
+ ABCxxxxx := '10100000'B,
+ PDU_length := 14,
+ id := id_E3,
+ payload := 'ABCD'O}
+
+ const octetstring o :='00000003A000000E00000002ABCD'O ;
+
+ if ((enc_RAW_PDU_168(i) == o )and(dec_RAW_PDU_168(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_168(i)= ", enc_RAW_PDU_168(i), "; dec_RAW_PDU_168(o)= ", dec_RAW_PDU_168(o));}
+
+}
+
+
+//=================================
+// group raw attribute test 1
+//=================================
+
+group RAW_group46 {
+ type integer RAW_PDU_169
+} with { encode "RAW";
+ variant "FIELDLENGTH(8)" ;
+ variant "COMP( 2scompl ) "
+ };
+
+external function enc_RAW_PDU_169(in RAW_PDU_169 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_169(in octetstring stream) return RAW_PDU_169 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_group_raw_attribute_test_1() runs on TempComp{
+ const RAW_PDU_169 i := -2
+ const octetstring o := 'FE'O
+
+
+ if ((enc_RAW_PDU_169(i) == o)and(dec_RAW_PDU_169(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_169(i)= ", enc_RAW_PDU_169(i), "; dec_RAW_PDU_169(o)= ", dec_RAW_PDU_169(o));}
+}
+
+//=================================
+// group raw attribute test 2
+//=================================
+
+type integer RAW_PDU_170
+with { encode "RAW";
+ variant "BITORDERINOCTET(msb)";
+ variant "BYTEORDER(last)";
+ variant "ALIGN(left)";
+ variant "BITORDERINFIELD(msb)";
+ variant "COMP(signbit)";
+ variant "FIELDLENGTH(20)" };
+external function enc_RAW_PDU_170(in RAW_PDU_170 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_170(in octetstring stream) return RAW_PDU_170 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_group_raw_attribute_test_2() runs on TempComp{
+ const RAW_PDU_170 i := -234
+ const octetstring o := 'EA0008'O
+
+ if ((enc_RAW_PDU_170(i) == o)and(dec_RAW_PDU_170(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_170(i)= ", enc_RAW_PDU_170(i), "; dec_RAW_PDU_170(o)= ", dec_RAW_PDU_170(o));}
+}
+
+//=================================
+// group raw attribute test 3
+//=================================
+
+group RAW_group47 {
+ group grp_v1 {
+ group grp_v2 {
+ group grp_v3 {
+ group grp_v4 {
+ group grp_v5 {
+ group grp_v6 {
+ type integer RAW_PDU_171
+ } with { variant "BITORDERINOCTET(msb)" }
+ } with { variant "BYTEORDER(last)" }
+ } with { variant "ALIGN(left)" }
+ } with { variant "BITORDERINFIELD(msb)" }
+ } with { variant "COMP(signbit)" }
+ } with { variant "FIELDLENGTH(20)" }
+} with { encode "RAW" }
+
+external function enc_RAW_PDU_171(in RAW_PDU_171 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_171(in octetstring stream) return RAW_PDU_171 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_group_raw_attribute_test_3() runs on TempComp{
+ const RAW_PDU_171 i := -234
+ const octetstring o := 'EA0008'O
+
+
+ if ((enc_RAW_PDU_171(i) == o)and(dec_RAW_PDU_171(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_171(i)= ", enc_RAW_PDU_171(i), "; dec_RAW_PDU_171(o)= ", dec_RAW_PDU_171(o));}
+}
+
+//=================================
+// group raw attribute test 4
+//=================================
+
+
+group RAW_group48 {
+ group grp_v1 {
+ group grp_v2 {
+ group grp_v3 {
+ group grp_v4 {
+ group grp_v5 {
+ group grp_v6 {
+ type integer RAW_PDU_172
+ with { variant "" }
+ } with { variant "FIELDLENGTH(20)"; variant "COMP(signbit)" }
+ } with { variant "BITORDERINFIELD(msb)"; variant "ALIGN(left)" }
+ } with { variant "BITORDERINOCTET(msb)"; variant "BYTEORDER(last)" }
+ } with { variant "BITORDERINOCTET(lsb)"; variant "BYTEORDER(first)" }
+ } with { variant "FIELDLENGTH(10)"; variant "COMP(2scompl)" }
+ } with { variant "BITORDERINFIELD(lsb)"; variant "ALIGN(right)" }
+
+} with { encode "RAW" }
+
+external function enc_RAW_PDU_172(in RAW_PDU_172 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_172(in octetstring stream) return RAW_PDU_172 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_group_raw_attribute_test_4() runs on TempComp{
+
+ const RAW_PDU_172 i := -234
+ const octetstring o := 'EA0008'O
+
+ if ((enc_RAW_PDU_172(i) == o)and(dec_RAW_PDU_172(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_172(i)= ", enc_RAW_PDU_172(i), "; dec_RAW_PDU_172(o)= ", dec_RAW_PDU_172(o));}
+}
+
+//=================================
+// group raw attribute test 5
+//=================================
+
+group RAW_group49 {
+ group grp_v1 {
+ group grp_v2 {
+ group grp_v3 {
+ type integer RAW_PDU_173
+ with { encode "RAW"; variant "" }
+ } with { encode "RAW"; variant "FIELDLENGTH(20)"; variant "COMP(signbit)" }
+ } with { encode "RAW"; variant "BITORDERINFIELD(msb)"; variant "ALIGN(left)" }
+ } with { encode "RAW"; variant "BITORDERINOCTET(msb)"; variant "BYTEORDER(last)" }
+} with { encode "RAW" }
+
+external function enc_RAW_PDU_173(in RAW_PDU_173 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_173(in octetstring stream) return RAW_PDU_173 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_group_raw_attribute_test_5() runs on TempComp{
+ const RAW_PDU_173 i := -234
+ const octetstring o := 'EA0008'O
+
+ if ((enc_RAW_PDU_173(i) == o)and(dec_RAW_PDU_173(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_173(i)= ", enc_RAW_PDU_173(i), "; dec_RAW_PDU_173(o)= ", dec_RAW_PDU_173(o));}
+
+}
+
+//=================================
+// group raw attribute test 6
+//=================================
+
+
+group RAW_group50 {
+ group grp_v1 {
+ group grp_v2 {
+ group grp_v3 {
+ type integer RAW_PDU_174
+ with { variant "" }
+ } with { variant override "FIELDLENGTH(32)" }
+ } with { variant "FIELDLENGTH(10)" }
+ } with { variant override "FIELDLENGTH(8)"; variant "FIELDLENGTH(2)" }
+} with { encode "RAW" }
+
+external function enc_RAW_PDU_174(in RAW_PDU_174 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_174(in octetstring stream) return RAW_PDU_174 with { extension "prototype(convert) decode(RAW)" }
+
+testcase TC_group_raw_attribute_test_6() runs on TempComp{
+ const RAW_PDU_174 i := 255
+ const octetstring o := 'FF'O
+
+ if ((enc_RAW_PDU_174(i) == o)and(dec_RAW_PDU_174(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_174(i)= ", enc_RAW_PDU_174(i), "; dec_RAW_PDU_174(o)= ", dec_RAW_PDU_174(o));}
+}
+//=================================
+// group raw attribute test 7
+//=================================
+external function enc_RAW_PDU_175(in RAW_PDU_175 pdu) return octetstring with { extension "prototype(convert) encode(RAW)" }
+external function dec_RAW_PDU_175(in octetstring stream) return RAW_PDU_175 with { extension "prototype(convert) decode(RAW)" }
+
+group RAW_group51{
+ group grp1 {
+ type record RAW_PDU_175
+ { integer int1 ,
+ integer int2 ,
+ integer int3 ,
+ integer int4 }
+ with { variant (int1,int2,int3,int4) "FIELDLENGTH(4)";
+ variant (int1,int2) "PADDING(yes)";
+ variant (int3,int4) "PADDING(no)"; }
+ } with { variant "FIELDLENGTH(3)" }
+} with {encode "RAW" };
+
+testcase TC_group_raw_attribute_test_7() runs on TempComp{
+ const RAW_PDU_175
+ i := { int1 := 1 ,
+ int2 := 2 ,
+ int3 := 3 ,
+ int4 := 4 }
+
+ const octetstring o := '010243'O
+
+ if ((enc_RAW_PDU_175(i) == o)and(dec_RAW_PDU_175(o) == i)) {setverdict(pass);}
+ else {setverdict(fail,"enc_RAW_PDU_175(i)= ", enc_RAW_PDU_175(i), "; dec_RAW_PDU_175(o)= ", dec_RAW_PDU_175(o));}
+
+}
+
+//=============================================================
+// Testing Enc/Dec functions of implicit message encoding
+//=============================================================
+//=================================
+// Fast enc/dec function
+//=================================
+
+
+type integer RAW_PDU_176 with { encode "RAW"; variant "FIELDLENGTH(16)" };
+
+external function enc_RAW_PDU_176(in RAW_PDU_176 pdu, out octetstring stream) with { extension "prototype(fast) encode(RAW)" }
+external function dec_RAW_PDU_176(in octetstring stream, out RAW_PDU_176 pdu) with { extension "prototype(fast) decode(RAW)" }
+
+testcase TC_Fast_enc_dec_function() runs on TempComp{
+ const RAW_PDU_176 i := 255
+ const octetstring o := 'FF00'O
+
+ var octetstring encoded_pdu;
+ var RAW_PDU_176 decoded_pdu;
+
+ enc_RAW_PDU_176(i, encoded_pdu);
+ dec_RAW_PDU_176(o, decoded_pdu);
+
+ if ( encoded_pdu == o and decoded_pdu == i ) {setverdict(pass);}
+ else {setverdict(fail,"encoded_pdu= ", encoded_pdu, "; decoded_pdu= ", decoded_pdu);}
+}
+//=================================================
+// Implicit message encoding: prototype backtrack
+//=================================================
+
+external function dec_RAW_PDU_177(in octetstring stream, out RAW_PDU_177 pdu) return integer
+ with { extension "prototype(backtrack) decode(RAW) errorbehavior(ALL:WARNING)" }
+
+type integer RAW_PDU_177 with { encode "RAW"; variant "FIELDLENGTH(16)" };
+
+
+testcase TC_Backtrack_decode_function() runs on TempComp{
+ const RAW_PDU_177 i := 255
+ const octetstring o1 := 'FF00'O
+ const octetstring o2 := '12'O
+
+ var RAW_PDU_177 decoded_pdu;
+ var integer ret_val;
+
+ ret_val := dec_RAW_PDU_177(o1, decoded_pdu);
+ if (ret_val==0 and decoded_pdu==i) {setverdict(pass);}
+ else {setverdict(fail,"dec_RAW_PDU_177(o1, decoded_pdu)=",ret_val,";decoded_pdu=", decoded_pdu );}
+
+ ret_val := dec_RAW_PDU_177(o2, decoded_pdu);
+ if (ret_val==1) {setverdict(pass);}
+ else {setverdict(fail,"ret_val=",ret_val,";decoded_pdu=", decoded_pdu );}
+}
+
+//=================================================
+// Sliding decode function
+//=================================================
+
+
+type integer RAW_PDU_178 with { encode "RAW"; variant "FIELDLENGTH(16)" };
+
+external function dec_RAW_PDU_178(inout octetstring stream, out RAW_PDU_178 pdu) return integer
+ with { extension "prototype(sliding) decode(RAW) errorbehavior(ALL:WARNING)" }
+
+testcase TC_Sliding_decode_function() runs on TempComp{
+ const RAW_PDU_178 i := 255
+ var octetstring o1 := 'FF00'O;
+ var octetstring o2 := '12'O;
+ var RAW_PDU_178 decoded_pdu;
+ var integer ret_val;
+
+ ret_val := dec_RAW_PDU_178(o1, decoded_pdu);
+ if (ret_val==0 and decoded_pdu==i) {setverdict(pass);}
+ else {setverdict(fail,"ret_val=",ret_val,";decoded_pdu=", decoded_pdu );}
+
+ ret_val := dec_RAW_PDU_178(o2, decoded_pdu);
+ if (ret_val>0) {setverdict(pass);}
+ else {setverdict(fail,"ret_val=",ret_val,";decoded_pdu=", decoded_pdu );}
+}
+
+//---------------------------------------------------------------------*
+// Testing limits of codec
+//---------------------------------------------------------------------*
+
+//=================================================
+// Decoding empty octetstring to PDU
+//=================================================
+
+type record RAW_PDU_179 {
+ integer f1,
+ octetstring f2,
+ boolean f3
+} with { encode "RAW" variant "" }
+
+external function decodePDU(inout octetstring os, out RAW_PDU_179 pdu) return integer
+with { extension "prototype(sliding) decode(RAW) errorbehavior(ALL:WARNING)" }
+
+testcase TC_Decoding_empty_octetstring() runs on TempComp{
+ var octetstring os := ''O;
+ var RAW_PDU_179 pdu;
+ var integer ret_val := decodePDU(os, pdu);
+ if (ret_val>0) {setverdict(pass);}
+ else {setverdict(fail,"ret_val=",ret_val,";decoded pdu=", pdu );}
+}
+
+//---------------------------------------------------------------------*
+// Testing encoding/decoding of big integers
+//---------------------------------------------------------------------*
+//=================================================
+// encoding/decoding of big integer variables
+//=================================================
+
+type integer myint2
+with {
+ variant "FIELDLENGTH(128)"
+ variant "COMP(nosign)"
+ variant "BITORDERINFIELD(lsb)"
+ variant "PADDING(dword32)"
+ encode "RAW" }
+
+type integer myint3
+with {
+ variant "FIELDLENGTH(96)"
+ variant "COMP(signbit)"
+ variant "BITORDERINFIELD(lsb)"
+ variant "PADDING(dword32)"
+ encode "RAW" }
+
+external function enc_raw3(in myint3 r) return octetstring
+ with { extension "encode(RAW) prototype(convert) errorbehavior(ALL:WARNING)" }
+external function dec_raw3(in octetstring r) return myint3
+ with { extension "decode(RAW) prototype(convert) errorbehavior(ALL:WARNING)" }
+external function enc_raw2(in myint2 r) return octetstring
+ with { extension "encode(RAW) prototype(convert) errorbehavior(ALL:WARNING)" }
+external function dec_raw2(in octetstring r) return myint2
+ with { extension "decode(RAW) prototype(convert) errorbehavior(ALL:WARNING)" }
+
+testcase TC_encoding_decoding_of_big_integers() runs on TempComp{
+ var myint3 v1 := -4294967296
+ var myint3 v2 := -2147483647
+ var myint3 v3 := 34359738368
+ var myint3 v4 := 4398046511104
+ var myint3 v5 := -140737488355328
+ var myint3 v6 := 4294967296
+ var myint3 v7 := 4294967295
+ var myint3 v8 := -4294967295
+ var myint3 v9 := 4294967297
+ var myint3 v10 := -4294967297
+ var myint3 v11 := 2147483647
+ var myint3 v12 := -2147483648
+ var myint3 v13 := 2147483648
+ var myint3 v14 := -2147483649
+ var myint3 v15 := 2147483649
+ var myint2 v16 := -4294967296
+ var myint2 v17 := 2147483647
+ var myint2 v18 := 34359738368
+ var myint2 v19 := 4398046511104
+ var octetstring o
+
+ var octetstring expected1 := '000000000100000000000080'O //fact: '00000000FF00000000000080'O
+ var octetstring expected2 := 'FFFF FF7F 0000 0000 0000 0080'O;
+ var octetstring expected3 := '0000 0000 0800 0000 0000 0000'O;
+ var octetstring expected4 := '0000 0000 0004 0000 0000 0000'O //dummy
+ var octetstring expected5 := '0000 0000 0080 0000 0000 0080'O //dummy
+ var octetstring expected6 := '0000 0000 0100 0000 0000 0000'O //dummy
+ var octetstring expected7 := 'FFFF FFFF 0000 0000 0000 0000'O //dummy
+ var octetstring expected8 := 'FFFF FFFF 0000 0000 0000 0080'O //dummy
+
+ var octetstring expected9 := '0100 0000 0100 0000 0000 0000'O //dummy
+ var octetstring expected10 := '0100 0000 0100 0000 0000 0080'O
+
+ var octetstring expected11 := 'FFFF FF7F 0000 0000 0000 0000'O
+
+ var octetstring expected12 := '0000 0080 0000 0000 0000 0080'O;
+ var octetstring expected13 := '0000 0080 0000 0000 0000 0000'O;
+
+ var octetstring expected14 := '0100 0080 0000 0000 0000 0080'O;
+// var octetstring expected15 := '0100 0080 0000 0000 0000 0000'O;
+// var octetstring expected16 := '0000 0000 0000 0000 0000 0000'O;
+// var octetstring expected17 := '0000 0000 0000 0000 0000 0000'O;
+// var octetstring expected18 := '0000 0000 0000 0000 0000 0000'O;
+// var octetstring expected19 := '0000 0000 0000 0000 0000 0000'O;
+
+ o := enc_raw3(v1);
+ if ( o == expected1) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 1. Expected: ",expected1, "; got: ",o)}
+ if (v1 == dec_raw3(expected1)) {setverdict(pass)}
+ else {setverdict(fail, "1. Decoding error of ",expected1, " ;Expected:", v1," got ", dec_raw3(expected1) )}
+
+ o := enc_raw3(v2);
+ if ( o == expected2) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 2. Expected: ",expected2, "; got: ",o)}
+ if (v2 == dec_raw3(expected2)) {setverdict(pass)}
+ else {setverdict(fail, "2. Decoding error of ",expected2, " ;Expected: ", v2," got ", dec_raw3(expected2) )}
+
+
+ o := enc_raw3(v3);
+ if ( o == expected3) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 3. Expected: ",expected3, "; got: ",o)}
+ if (v3 == dec_raw3(expected3)) {setverdict(pass)}
+ else {setverdict(fail, "3. Decoding error of ",expected3, " ;Expected: ", v3," got ", dec_raw3(expected3) )}
+
+ o := enc_raw3(v4);
+ if ( o == expected4) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 4. Expected: ",expected4, "; got: ",o)}
+ if (v4 == dec_raw3(expected4)) {setverdict(pass)}
+ else {setverdict(fail, "4. Decoding error of ",expected4, " ;Expected: ", v4," got ", dec_raw3(expected4) )}
+
+ o := enc_raw3(-140737488355328);
+ if ( o == expected5) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 5. Expected: ",expected5, "; got: ",o)}
+ if (v5 == dec_raw3(expected5)) {setverdict(pass)}
+ else {setverdict(fail, "5. Decoding error of ",expected5, " ;Expected: ", v5," got ", dec_raw3(expected5) )}
+
+ o := enc_raw3(v6);
+ if ( o == expected6) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 6. Expected: ",expected6, "; got: ",o)}
+ if (v6 == dec_raw3(expected6)) {setverdict(pass)}
+ else {setverdict(fail, "6. Decoding error of ",expected6, " ;Expected: ", v6," got ", dec_raw3(expected6) )}
+
+ o := enc_raw3(v7);
+ if ( o == expected7) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 7. Expected: ",expected7, "; got: ",o)}
+ if (v7 == dec_raw3(expected7)) {setverdict(pass)}
+ else {setverdict(fail, "7. Decoding error of ",expected7, " ;Expected: ", v7," got ", dec_raw3(expected7) )}
+
+ o := enc_raw3(v8);
+ if ( o == expected8) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 8. Expected: ",expected8, "; got: ",o)}
+ if (v8 == dec_raw3(expected8)) {setverdict(pass)}
+ else {setverdict(fail, "8. Decoding error of ",expected8, " ;Expected: ", v8," got ", dec_raw3(expected8) )}
+
+ o := enc_raw3(v9);
+ if ( o == expected9) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 9. Expected: ",expected9, "; got: ",o)}
+ if (v9 == dec_raw3(expected9)) {setverdict(pass)}
+ else {setverdict(fail, "9. Decoding error of ",expected9, " ;Expected: ", v9," got ", dec_raw3(expected9) )}
+
+ o := enc_raw3(v10);
+ if ( o == expected10) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 10. Expected: ",expected10, "; got: ",o)}
+ if (v10 == dec_raw3(expected10)) {setverdict(pass)}
+ else {setverdict(fail, "10. Decoding error of ",expected10, " ;Expected: ", v10," got ", dec_raw3(expected10) )}
+
+ o := enc_raw3(v11);
+ if ( o == expected11) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 11. Expected: ",expected11, "; got: ",o)}
+ if (v11 == dec_raw3(expected11)) {setverdict(pass)}
+ else {setverdict(fail, "11. Decoding error of ",expected11, " ;Expected: ", v11," got ", dec_raw3(expected11) )}
+
+ o := enc_raw3(v12);
+ if ( o == expected12) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 12. Expected: ",expected12, "; got: ",o)}
+ if (v12 == dec_raw3(expected12)) {setverdict(pass)}
+ else {setverdict(fail, "12. Decoding error of ",expected12, " ;Expected: ", v12," got ", dec_raw3(expected12) )}
+
+ o := enc_raw3(v13);
+ if ( o == expected13) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 12. Expected: ",expected13, "; got: ",o)}
+ if (v13 == dec_raw3(expected13)) {setverdict(pass)}
+ else {setverdict(fail, "13. Decoding error of ",expected13, " ;Expected: ", v13," got ", dec_raw3(expected13) )}
+
+ o := enc_raw3(v14);
+ if ( o == expected14) { setverdict(pass) }
+ else { setverdict(fail, "Encoding error 14. Expected: ",expected14, "; got: ",o)}
+ if (v14 == dec_raw3(expected14)) {setverdict(pass)}
+ else {setverdict(fail, "14. Decoding error of ",expected14, " ;Expected: ", v14," got ", dec_raw3(expected14) )}
+}
+//=================================================
+// Encoding/decoding records with big integer fields
+//=================================================
+
+external function enc_raw(in rec_raw1 r) return octetstring
+ with { extension "encode(RAW) prototype(convert) errorbehavior(ALL:WARNING)" }
+external function dec_raw(in octetstring r) return rec_raw1
+ with { extension "decode(RAW) prototype(convert) errorbehavior(ALL:WARNING)" }
+
+type integer myint1
+with {
+ variant "FIELDLENGTH(256)"
+ variant "COMP(2scompl)"
+ variant "BITORDERINFIELD(lsb)"
+ variant "PADDING(dword32)"
+ encode "RAW" } // The script eats the trailing '}' in a new line.
+
+type record rec_raw1 {
+ myint1 int1,
+ myint1 int2
+} with { variant "" encode "RAW" }
+
+
+testcase TC_encoding_decoding_records_with_big_integer_fields() runs on TempComp{
+ var rec_raw1 myrec1 := {int1 := -12345678910111213141516, int2 := -3}
+ var octetstring o1 := 'F44174CD76A949BD62FDFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O;
+ var rec_raw1 myrec2 := {int1 := -11111111111111111111111, int2 := -11111111111111111111111}
+ var octetstring o2 := '398E6356A2915BAAA5FDFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF398E6356A2915BAAA5FDFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O;
+ var rec_raw1 myrec3 := {int1 := -2147483648, int2 := -4294967296}
+ var octetstring o3 := '00000080FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O;
+ var rec_raw1 myrec4 := {int1 := 2147483648, int2 := -4294967296}
+ var octetstring o4 := '000000800000000000000000000000000000000000000000000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O;
+ var rec_raw1 myrec5 := {int1 := -2147483649, int2 := 2147483649}
+ var octetstring o5 := 'FFFFFF7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0100008000000000000000000000000000000000000000000000000000000000'O;
+ var rec_raw1 myrec6 := {int1 := -1234, int2 := -4321}
+ var octetstring o6 := '2EFBFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF1FEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF'O;
+
+ if (o1 == enc_raw(myrec1)) {setverdict(pass)}
+ else {setverdict(fail, "myrec1: ", myrec1, "; enc_raw(myrec1): ", enc_raw(myrec1), ";Expected: ",o1)}
+
+ if (myrec1 == dec_raw(o1)) {setverdict(pass)}
+ else {setverdict(fail, "o1: ", o1, ";dec_raw(o1):", dec_raw(o1), ";Expected: ", myrec1)}
+
+ if (o2 == enc_raw(myrec2)) {setverdict(pass)}
+ else {setverdict(fail, "myrec2: ", myrec2, "; enc_raw(myrec2): ", enc_raw(myrec2), ";Expected: ",o2)}
+
+ if (myrec2 == dec_raw(o2)) {setverdict(pass)}
+ else {setverdict(fail, "o2: ", o2, ";dec_raw(o2):", dec_raw(o2), ";Expected: ", myrec2)}
+
+ if (o3 == enc_raw(myrec3)) {setverdict(pass)}
+ else {setverdict(fail, "myrec3: ", myrec3, "; enc_raw(myrec1): ", enc_raw(myrec3), ";Expected: ",o3)}
+
+ if (myrec3 == dec_raw(o3)) {setverdict(pass)}
+ else {setverdict(fail, "o3: ", o3, ";dec_raw(o3):", dec_raw(o3), ";Expected: ", myrec3)}
+
+ if (o4 == enc_raw(myrec4)) {setverdict(pass)}
+ else {setverdict(fail, "myrec4: ", myrec4, "; enc_raw(myrec4): ", enc_raw(myrec4), ";Expected: ",o4)}
+
+ if (myrec4 == dec_raw(o4)) {setverdict(pass)}
+ else {setverdict(fail, "o4: ", o4, ";dec_raw(o4):", dec_raw(o4), ";Expected: ", myrec4)}
+
+ if (o5 == enc_raw(myrec5)) {setverdict(pass)}
+ else {setverdict(fail, "myrec5: ", myrec5, "; enc_raw(myrec5): ", enc_raw(myrec5), ";Expected: ",o5)}
+
+ if (myrec5 == dec_raw(o5)) {setverdict(pass)}
+ else {setverdict(fail, "o5: ", o5, ";dec_raw(o5):", dec_raw(o5), ";Expected: ", myrec5)}
+
+ if (o6 == enc_raw(myrec6)) {setverdict(pass)}
+ else {setverdict(fail, "myrec6: ", myrec6, "; enc_raw(myrec6): ", enc_raw(myrec6), ";Expected: ",o6)}
+
+ if (myrec6 == dec_raw(o6)) {setverdict(pass)}
+ else {setverdict(fail, "o6: ", o6, ";dec_raw(o6):", dec_raw(o6), ";Expected: ", myrec6)}
+
+}
+
+//=================================================
+// Multiple optional fields (R8G FOA bug)
+//=================================================
+
+external function enc_PDU_GTPCv2(in PDU_GTPCv2 pdu) return octetstring
+with { extension "prototype(convert)" extension "encode(RAW)" }
+
+external function dec_PDU_GTPCv2(in octetstring stream) return PDU_GTPCv2
+with { extension "prototype(convert)" extension "decode(RAW)" }
+
+type bitstring BIT5 length(5) with { encode "RAW" variant "FIELDLENGTH(5)" };
+
+type octetstring OCT1_ length(1) with { encode "RAW" variant "FIELDLENGTH(1)" };
+type octetstring OCT4 length(4) with { encode "RAW" variant "FIELDLENGTH(4)" };
+type integer LIN1 (0..255) with { encode "RAW" variant "FIELDLENGTH(8)" };
+
+type integer LIN2_BO_LAST (0..65535) with { encode "RAW" variant "FIELDLENGTH(16), COMP(nosign), BYTEORDER(last)" };
+
+type record Cause {
+ OCT1_ elementIdentifier, //dec 2, '02'O
+ LIN2_BO_LAST lengthIndicator,
+ BIT4 instance,
+ BIT4 spare,
+ OCT1_ causeValue,
+ BIT1 cS,
+ BIT1 bCE,
+ BIT1 pCE,
+ BIT5 spare2,
+ OCT1_ typeOfOffendingIE optional,
+ LIN2_BO_LAST lengthIndicator2 optional,
+ BIT4 instanceOfOffendingIE optional,
+ BIT4 spare3 optional
+} with { encode "RAW"
+ variant "PRESENCE (elementIdentifier = '02'O; )"
+ variant (lengthIndicator) "LENGTHTO(causeValue,cS,bCE,pCE,spare2,typeOfOffendingIE,
+ lengthIndicator2,instanceOfOffendingIE,spare3 )" };
+
+type record Recovery {
+ OCT1_ elementIdentifier, // dec 3, '03'O
+ LIN2_BO_LAST lengthIndicator,
+ BIT4 instance,
+ BIT4 spare,
+ integer recoveryValue
+} with { encode "RAW"
+ variant (lengthIndicator) "LENGTHTO(recoveryValue)"
+ variant "PRESENCE (elementIdentifier = '03'O; )" };
+
+type set of ProtocolID_or_ContainerID ProtocolIDs_and_ContainerIDs;
+
+type record ProtocolID_or_ContainerID {
+ OCT2 protocolID_or_ContainerID,
+ LIN1 lengthIndicator,
+ octetstring protID_orContID_Contents
+} with { encode "RAW"
+ variant (lengthIndicator) "LENGTHTO (protID_orContID_Contents)"};
+
+type record ProtocolConfigOptions {
+ OCT1_ elementIdentifier, // dec 78 '4E'O;
+ LIN2_BO_LAST lengthIndicator,
+ BIT4 instance,
+ BIT4 spare,
+ BIT3 configProtocol,
+ BIT4 spare2, //'0000'B
+ BIT1 extensionField, //'1'B
+ ProtocolIDs_and_ContainerIDs protocolIDs_and_ContainerIDs optional
+} with { encode "RAW"
+ variant (lengthIndicator) "LENGTHTO(configProtocol,spare2,extensionField,protocolIDs_and_ContainerIDs)"
+ variant "PRESENCE (elementIdentifier = '4E'O; )" };
+
+type record PrivateExtension {
+ OCT1_ elementIdentifier, // dec 255, 'FF'O
+ LIN2_BO_LAST lengthIndicator,
+ BIT4 instance,
+ BIT4 spare,
+ integer enterpriseID,
+ octetstring proprietartyValue
+} with { encode "RAW"
+ variant (lengthIndicator) "LENGTHTO(enterpriseID,proprietartyValue)";
+ variant "PRESENCE (elementIdentifier = 'FF'O;)"; };
+
+type set DeleteSessionResponse {
+ Cause cause,
+ Recovery recovery optional,
+ ProtocolConfigOptions protocolConfigOptions optional,
+ PrivateExtension privateExtension optional };
+
+type union GTPCv2_PDUs {
+ DeleteSessionResponse deleteSessionResponse };
+
+type record PDU_GTPCv2 {
+ BIT3 spare, //0
+ BIT1 t_Bit,
+ BIT1 p_Bit,
+ BIT3 version, //'010'B
+ OCT1_ messageType,
+ LIN2_BO_LAST lengthf,
+ OCT4 tEID optional,
+ OCT3 sequenceNumber,
+ OCT1_ spare3, // 0
+ GTPCv2_PDUs gtpcv2_pdu,
+ PDU_GTPCv2 piggybackPDU_GTPCv2 optional
+} with { encode "RAW"
+ variant (tEID) "PRESENCE(t_Bit = '1'B)";
+ variant (piggybackPDU_GTPCv2) "PRESENCE(p_Bit = '1'B)";
+ variant (lengthf) "LENGTHTO(tEID,sequenceNumber,spare3,gtpcv2_pdu)";
+ variant (gtpcv2_pdu) "CROSSTAG(
+ deleteSessionResponse, messageType = '25'O; //37
+ )"; };
+
+testcase TC_Multiple_optional_fields() runs on TempComp{
+ var PDU_GTPCv2 vl_temp := dec_PDU_GTPCv2( '48250013800000000249BF000200020010000300010011'O );
+ setverdict(pass);
+}
+
+//===========================================
+// CONTROL PART
+//===========================================
+control {
+ execute (TC_FIELDLENGTH_16_for_integer());
+ execute (TC_FIELDLENGTH_8_for_integer());
+ execute (TC_FIELDLENGTH_4_for_integer());
+ execute (TC_FIELDLENGTH_16_for_integer_2());
+ execute (TC_FIELDLENGTH_32_for_integer_1_bit_long());
+ execute (TC_Default_FIELDLENGTH_for_integer());
+ execute (TC_FIELDLENGTH_8_for_bitstring());
+ execute (TC_FIELDLENGTH_8_for_bitstring_4_bits_long());
+ execute (TC_FIELDLENGTH_4_for_bitstring());
+ execute (TC_FIELDLENGTH_16_for_bitstring());
+ execute (TC_FIELDLENGTH_24_for_bitstring());
+ execute (TC_FIELDLENGTH_0_for_bitstring());
+ execute (TC_DEFAULT_FIELDLENGTH_for_bitstring());
+ execute (TC_FIELDLENGTH_32_for_bitstring_4_bits_long());
+ execute (TC_FIELDLENGTH_1_for_octetstring());
+ execute (TC_FIELDLENGTH_2_for_octetstring());
+ execute (TC_FIELDLENGTH_2_and_BYTEORDER_first_for_octetstring());
+ execute (TC_FIELDLENGTH_2_and_BYTEORDER_last_for_octetstring());
+ execute (TC_FIELDLENGTH_4_and_BYTEORDER_first_for_octetstring());
+ execute (TC_FIELDLENGTH_4_for_octetstring_3_octets_long());
+ execute (TC_FIELDLENGTH_5_for_octetstring_2_octets_long());
+ execute (TC_FIELDLENGTH_4_and_BYTEORDER_last_for_octetstring());
+ execute (TC_FIELDLENGTH_4_and_BYTEORDER_last_for_octetstring_3_octets_long());
+ execute (TC_Default_FIELDLENGTH_for_octetstring());
+ execute (TC_FIELDLENGTH_0_for_octetstring());
+ execute (TC_FIELDLENGTH_4_for_hexstring());
+ execute (TC_FIELDLENGTH_8_for_hexstring());
+ execute (TC_DEFAULT_FIELDLENGTH_for_hexstring());
+ execute (TC_FIELDLENGTH_0_for_hexstring());
+ execute (TC_FIELDLENGTH_12_for_hexstring_2_hex_long());
+ execute (TC_FIELDLENGTH_4_for_enumerated());
+ execute (TC_FIELDLENGTH_32_for_enumerated());
+ execute (TC_Default_FIELDLENGTH_for_enumerated());
+ execute (TC_FIELDLENGTH_with_length_restriction_bitstring());
+ execute (TC_FIELDLENGTH_with_length_restriction_hexstring());
+ execute (TC_FIELDLENGTH_with_length_restriction_octetstring());
+ execute (TC_FIELDLENGTH_with_length_restriction_record());
+ execute (TC_FIELDLENGTH_with_length_restriction_record_of());
+ execute (TC_FIELDLENGTH_with_length_restriction_set());
+ execute (TC_FIELDLENGTH_with_length_restriction_set_of());
+//error execute (TC_FIELDLENGTH_with_length_restriction_and_align_bitstring());
+ execute (TC_FIELDLENGTH_with_length_restriction_and_align_hexstring());
+ execute (TC_FIELDLENGTH_with_length_restriction_and_align_octetstring());
+ execute (TC_BYTEORDER_first_for_integer_0());
+ execute (TC_BYTEORDER_first_for_integer_1());
+ execute (TC_BYTEORDER_first_for_integer_18());
+ execute (TC_BYTEORDER_first_and_fieldlength_8_for_integer());
+ execute (TC_BYTEORDER_first_and_fieldlength_16_for_integer());
+ execute (TC_BYTEORDER_last_for_integer_0());
+ execute (TC_BYTEORDER_last_for_integer_1());
+ execute (TC_BYTEORDER_last_for_integer_18());
+ execute (TC_BYTEORDER_last_and_fieldlength_8_for_integer());
+ execute (TC_BYTEORDER_last_and_fieldlength_16_for_integer());
+ execute (TC_BYTEORDER_first_for_bitstring());
+ execute (TC_BYTEORDER_last_for_bitstring());
+ execute (TC_BYTEORDER_first_for_octetstring());
+ execute (TC_BYTEORDER_last_for_octetstring());
+ execute (TC_BYTEORDER_first_for_enumerated());
+ execute (TC_BYTEORDER_last_for_enumerated());
+ execute (TC_BYTEORDER_first_for_hexstring());
+ execute (TC_BYTEORDER_last_for_hexstring());
+ execute(TC_BITORDERINFIELD_lsb_for_integer_8());
+ execute(TC_BITORDERINFIELD_msb_for_integer_8());
+ execute(TC_BITORDERINFIELD_lsb_for_integer_16());
+ execute(TC_BITORDERINFIELD_msb_for_integer_16());
+ execute(TC_BITORDERINFIELD_lsb_for_octetstring_1());
+ execute(TC_BITORDERINFIELD_msb_for_octetstring_1());
+ execute(TC_BITORDERINFIELD_lsb_for_octetstring_2());
+ execute(TC_BITORDERINFIELD_msb_for_octetstring_2());
+ execute(TC_BITORDERINFIELD_lsb_for_bitstring_8());
+ execute(TC_BITORDERINFIELD_msb_for_bitstring_8());
+ execute(TC_BITORDERINFIELD_lsb_for_bitstring_16());
+ execute(TC_BITORDERINFIELD_msb_for_bitstring_16());
+ execute(TC_BITORDERINFIELD_lsb_for_enumerated_4());
+ execute(TC_BITORDERINFIELD_msb_for_enumerated_8());
+ execute(TC_BITORDERINFIELD_lsb_for_hexstring());
+ execute(TC_BITORDERINFIELD_msb_for_hexstring());
+ execute(TC_BITORDERINOCTET_lsb_for_integer_8());
+ execute(TC_BITORDERINOCTET_msb_for_integer_8());
+ execute(TC_BITORDERINOCTET_lsb_for_integer_16());
+ execute(TC_BITORDERINOCTET_msb_for_integer_16());
+ execute(TC_BITORDERINOCTET_lsb_for_octetstring_1());
+ execute(TC_BITORDERINOCTET_msb_for_octetstring_1());
+ execute(TC_BITORDERINOCTET_lsb_for_octetstring_2());
+ execute(TC_BITORDERINOCTET_msb_for_octetstring_2());
+ execute(TC_BITORDERINOCTET_lsb_for_bitstring_8());
+ execute(TC_BITORDERINOCTET_msb_for_bitstring_8());
+ execute(TC_BITORDERINOCTET_lsb_for_bitstring_16());
+ execute(TC_BITORDERINOCTET_msb_for_bitstring_16());
+ execute(TC_BITORDERINOCTET_lsb_for_enumerated());
+ execute(TC_BITORDERINOCTET_msb_for_enumerated());
+ execute(TC_BITORDERINOCTET_lsb_for_hexstring());
+ execute(TC_BITORDERINOCTET_msb_for_hexstring());
+ execute(TC_COMP_nosign_for_positive_integer_8());
+ execute(TC_COMP_signbit_for_positive_integer_8());
+ execute(TC_COMP_signbit_for_negative_integer_8());
+ execute(TC_COMP_2scompl_for_positive_integer_8());
+ execute(TC_COMP_2scompl_for_negative_integer_8());
+ execute(TC_PADDING_for_integer()); //100
+ execute(TC_PADDING_for_bitstring());
+ execute(TC_PADDING_for_enumerated());
+ execute(TC_PADDING_for_hexstring());
+ execute(TC_PREPADDING_yes_for_bitstring());
+ execute(TC_PREPADDING_yes_for_hexstring());
+ execute(TC_PREPADDING_word16_for_octetstring());
+ execute(TC_PREPADDING_word16_for_record_of());
+ execute(TC_PREPADDING_dword32_for_set_of());
+ execute(TC_PREPADDING_dword32_for_record());
+ execute(TC_PREPADDING_word16_for_set());
+ execute(TC_PREPADDING_word16_for_union());
+ execute(TC_PADDING_PATTERN_for_record_of());
+ execute(TC_PADDING_PATTERN_for_set_of());
+ execute(TC_PADDING_PATTERN_for_record());
+ execute(TC_PADDING_PATTERN_for_set());
+ execute(TC_PADDING_PATTERN_for_union());
+ execute(TC_PADDALL_with_PADDING_Attribute_record());
+ execute(TC_PADDALL_with_PADDING_Attribute_set());
+ execute(TC_PADDALL_with_PREPADDING_Attribute_record());
+ execute(TC_PADDALL_with_PREPADDING_Attribute_set());
+ execute(TC_PTROFFSET_is_set_to_default_base());//120
+ execute(TC_PTROFFSET_is_set_to_the_beginning_of_record());
+ execute(TC_PTROFFSET_is_set_to_data_field());
+ execute(TC_HEXORDER_low_for_hexstring());
+ execute(TC_HEXORDER_high_for_hexstring());
+ execute(TC_EXTENSION_BIT_no_for_octetstring());
+ execute(TC_EXTENSION_BIT_yes_for_octetstring());
+ execute(TC_EXTENSION_BIT_reverse_for_octetstring());
+ execute(TC_EXTENSION_BIT_yes_for_record_of_octetstring());
+ execute(TC_EXTENSION_BIT_no_for_record_of_octetstring());
+ execute(TC_EXTENSION_BIT_yes_for_record_of_bitstring());
+ execute(TC_EXTENSION_BIT_reverse_for_record_of_bitstring());
+ execute(TC_EXTENSION_BIT_yes_for_set_of_bitstring());
+ execute(TC_EXTENSION_BIT_reverse_for_set_of_bitstring());
+ execute(TC_EXTENSION_BIT_yes_for_set_of_hexstring());
+ execute(TC_EXTENSION_BIT_reverse_for_set_of_hexstring());
+ execute(TC_record_with_EXTENSION_BIT_1());
+ execute(TC_record_with_EXTENSION_BIT_2());
+ execute(TC_record_with_EXTENSION_BIT_3());
+ execute(TC_record_with_EXTENSION_BIT_4());
+ execute(TC_record_with_EXTENSION_BIT_5());
+ execute(TC_record_with_EXTENSION_BIT_6());
+ execute(TC_record_with_EXTENSION_BIT_7());
+ execute(TC_record_with_EXTENSION_BIT_8());
+ execute(TC_record_with_EXTENSION_BIT_9());
+ execute(TC_EXTENSION_BIT_GROUP_no());
+ execute(TC_EXTENSION_BIT_GROUP_yes());
+ execute(TC_EXTENSION_BIT_GROUP_yes_2_groups());
+ execute(TC_EXTENSION_BIT_GROUP_yes_reverse_2_groups());
+ execute(TC_ALIGN_right_for_octetstring());
+ execute(TC_ALIGN_left_for_octetstring());
+ execute(TC_ALIGN_right_for_bitstring());
+ execute(TC_ALIGN_left_for_bitstring());
+ execute(TC_record_with_integer_and_octetstring());
+ execute(TC_record_with_default_values_in_field());
+ execute(TC_record_with_bitstring());
+ execute(TC_record_with_enumerated_and_fieldlength_calculation());
+ execute(TC_record_called_from_record());
+ execute(TC_union_called_from_record_with_CROSSTAG());
+ execute(TC_union_called_from_record_with_CROSSTAG_OTHERWISE());
+ execute(TC_record_without_specifying_the_default_attributes_for_fields());
+ execute(TC_record_of_called_from_record());
+ execute(TC_set_with_TAG());
+ execute(TC_union_with_TAG_first_element_called());
+ execute(TC_union_with_TAG_second_element_called());
+ execute(TC_union_with_TAG_third_element_called());
+ execute(TC_union_with_TAG_third_element_called_with_OTHERWISE());
+ execute(TC_set_of_called_from_record());
+ execute(TC_record_with_optional_field_with_PRESENCE());
+ execute(TC_record_with_UNIT());
+ execute(TC_record_with_PTRUNIT());
+ execute(TC_record_with_PTROFFSET());
+ execute(TC_structured_types_1());
+ execute(TC_structured_types_2());
+ execute(TC_structured_types_3());
+ execute(TC_structured_types_4());
+ execute(TC_structured_types_5());
+ execute(TC_structured_types_6());
+ execute(TC_structured_types_7());
+ execute(TC_structured_types_8());
+ execute(TC_structured_types_9());
+ execute(TC_structured_types_10());
+ execute(TC_structured_types_11());
+ execute(TC_structured_types_12());
+ execute(TC_structured_types_13());
+ execute(TC_structured_types_14());
+ execute(TC_structured_types_15());
+ execute(TC_structured_types_16());
+ execute(TC_structured_types_17());
+ execute(TC_Raw_update_test_1());
+ execute(TC_Raw_update_test_2());
+ execute(TC_Raw_update_test_3());
+ execute(TC_Raw_update_test_4());
+ execute(TC_Raw_update_test_5());
+ execute(TC_Raw_update_test_6());
+ execute(TC_Raw_update_test_7());
+ execute(TC_Raw_update_test_8());
+ execute(TC_Raw_update_test_9());
+ execute(TC_Raw_update_test_10());
+ execute(TC_Raw_update_test_11());
+ execute(TC_Raw_update_test_12());
+ execute(TC_Raw_update_test_13());
+ execute(TC_Raw_update_test_14());
+ execute(TC_Raw_update_test_15());
+ execute(TC_Raw_update_test_16());
+ execute(TC_group_raw_attribute_test_1());
+ execute(TC_group_raw_attribute_test_2());
+ execute(TC_group_raw_attribute_test_3());
+ execute(TC_group_raw_attribute_test_4());
+ execute(TC_group_raw_attribute_test_5());
+ execute(TC_group_raw_attribute_test_6());
+ execute(TC_group_raw_attribute_test_7());
+ execute(TC_Fast_enc_dec_function());
+ execute(TC_Backtrack_decode_function());
+ execute(TC_Sliding_decode_function());
+ execute(TC_Decoding_empty_octetstring());
+ execute(TC_encoding_decoding_of_big_integers());
+ execute(TC_encoding_decoding_records_with_big_integer_fields());
+ execute(TC_Multiple_optional_fields()); //FOA bug
+}
+}
diff --git a/Regression_Test_java/src/SelectUnion.ttcn b/Regression_Test_java/src/SelectUnion.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..f8e40eaf7b53c14f187a14b7815d63b47915b564
--- /dev/null
+++ b/Regression_Test_java/src/SelectUnion.ttcn
@@ -0,0 +1,323 @@
+/******************************************************************************
+ * 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:
+ * Szabo, Bence Janos
+ *
+ ******************************************************************************/
+
+module SelectUnion {
+
+type component EmptyCT {};
+
+type union Messages {
+ integer msg1,
+ bitstring msg2,
+ boolean msg3,
+ octetstring msg4,
+ charstring msg5
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+function f_select_union_without_else(in Messages p_msg, out integer result) {
+ select union (p_msg) {
+ case (msg1) { result := 1; }
+ case (msg2) { result := 2; }
+ case (msg3) { result := 3; }
+ case (msg4) { result := 4; }
+ case (msg5) { result := 5; }
+ }
+}
+
+
+testcase tc_SelectUnionWithoutElse() runs on EmptyCT {
+ var integer result;
+ var Messages myMessage;
+
+ myMessage.msg1 := 42;
+ f_select_union_without_else(myMessage, result);
+ if (result != 1) {
+ setverdict(fail);
+ }
+
+ myMessage.msg2 := '0000'B;
+ f_select_union_without_else(myMessage, result);
+ if (result != 2) {
+ setverdict(fail);
+ }
+
+ myMessage.msg3 := false;
+ f_select_union_without_else(myMessage, result);
+ if (result != 3) {
+ setverdict(fail);
+ }
+
+ myMessage.msg4 := 'AAAA'O;
+ f_select_union_without_else(myMessage, result);
+ if (result != 4) {
+ setverdict(fail);
+ }
+
+ myMessage.msg5 := "lorem ipsum";
+ f_select_union_without_else(myMessage, result);
+ if (result != 5) {
+ setverdict(fail);
+ }
+ setverdict(pass);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+function f_select_union_with_else(in Messages p_msg, out integer result) {
+ select union (p_msg) {
+ case (msg1) { result := 1; }
+ case else { result := 0; }
+ }
+}
+
+
+testcase tc_SelectUnionWithElse() runs on EmptyCT {
+ var integer result;
+ var Messages myMessage;
+
+ myMessage.msg1 := 42;
+ f_select_union_with_else(myMessage, result);
+ if (result != 1) {
+ setverdict(fail);
+ }
+
+ myMessage.msg2 := '0000'B;
+ f_select_union_with_else(myMessage, result);
+ if (result != 0) {
+ setverdict(fail);
+ }
+
+ myMessage.msg3 := false;
+ f_select_union_with_else(myMessage, result);
+ if (result != 0) {
+ setverdict(fail);
+ }
+
+ myMessage.msg4 := 'AAAA'O;
+ f_select_union_with_else(myMessage, result);
+ if (result != 0) {
+ setverdict(fail);
+ }
+
+ myMessage.msg5 := "lorem ipsum";
+ f_select_union_with_else(myMessage, result);
+ if (result != 0) {
+ setverdict(fail);
+ }
+ setverdict(pass);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+function f_select_union_anytype(in anytype p_msg, out integer result) {
+ select union (p_msg) {
+ case (integer) { result := 1; }
+ case (bitstring) { result := 2; }
+ case (boolean) { result := 3; }
+ case (octetstring) { result := 4; }
+ case (Messages) { result := 5; }
+ case else { result := 0; }
+ }
+}
+
+
+testcase tc_SelectUnionAnyType() runs on EmptyCT {
+ var integer result;
+ var anytype myAnyType;
+
+ myAnyType.integer := 42;
+ f_select_union_anytype(myAnyType, result);
+ if (result != 1) {
+ setverdict(fail);
+ }
+
+ myAnyType.bitstring := '0000'B;
+ f_select_union_anytype(myAnyType, result);
+ if (result != 2) {
+ setverdict(fail);
+ }
+
+ myAnyType.boolean := false;
+ f_select_union_anytype(myAnyType, result);
+ if (result != 3) {
+ setverdict(fail);
+ }
+
+ myAnyType.octetstring := 'AAAA'O;
+ f_select_union_anytype(myAnyType, result);
+ if (result != 4) {
+ setverdict(fail);
+ }
+
+ myAnyType.Messages.msg4 := 'AAAA'O;
+ f_select_union_anytype(myAnyType, result);
+ if (result != 5) {
+ setverdict(fail);
+ }
+
+ myAnyType.charstring := "lorem ipsum";
+ f_select_union_anytype(myAnyType, result);
+ if (result != 0) {
+ setverdict(fail);
+ }
+ setverdict(pass);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+function f_select_union_multiple_branches(in Messages p_msg, out integer result) {
+ select union (p_msg) {
+ case (msg1) { result := 1; }
+ case (msg2, msg3) { result := 2; }
+ case (msg4, msg5) { result := 3; }
+ }
+}
+
+
+testcase tc_SelectUnionMultipleBranches() runs on EmptyCT {
+ var integer result;
+ var Messages myMessage;
+
+ myMessage.msg1 := 42;
+ f_select_union_multiple_branches(myMessage, result);
+ if (result != 1) {
+ setverdict(fail);
+ }
+
+ myMessage.msg2 := '0000'B;
+ f_select_union_multiple_branches(myMessage, result);
+ if (result != 2) {
+ setverdict(fail);
+ }
+
+ myMessage.msg3 := false;
+ f_select_union_multiple_branches(myMessage, result);
+ if (result != 2) {
+ setverdict(fail);
+ }
+
+ myMessage.msg4 := 'AAAA'O;
+ f_select_union_multiple_branches(myMessage, result);
+ if (result != 3) {
+ setverdict(fail);
+ }
+
+ myMessage.msg5 := "lorem ipsum";
+ f_select_union_multiple_branches(myMessage, result);
+ if (result != 3) {
+ setverdict(fail);
+ }
+ setverdict(pass);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+function f_select_union_multiple_branches_anytype(in anytype p_msg, out integer result) {
+ select union (p_msg) {
+ case (integer) { result := 1; }
+ case (bitstring, boolean) { result := 2; }
+ case (octetstring, charstring) { result := 3; }
+ }
+}
+
+
+testcase tc_SelectUnionMultipleBranchesAnyType() runs on EmptyCT {
+ var integer result;
+ var anytype myMessage;
+
+ myMessage.integer := 42;
+ f_select_union_multiple_branches_anytype(myMessage, result);
+ if (result != 1) {
+ setverdict(fail);
+ }
+
+ myMessage.bitstring := '0000'B;
+ f_select_union_multiple_branches_anytype(myMessage, result);
+ if (result != 2) {
+ setverdict(fail);
+ }
+
+ myMessage.boolean := false;
+ f_select_union_multiple_branches_anytype(myMessage, result);
+ if (result != 2) {
+ setverdict(fail);
+ }
+
+ myMessage.octetstring := 'AAAA'O;
+ f_select_union_multiple_branches_anytype(myMessage, result);
+ if (result != 3) {
+ setverdict(fail);
+ }
+
+ myMessage.charstring := "lorem ipsum";
+ f_select_union_multiple_branches_anytype(myMessage, result);
+ if (result != 3) {
+ setverdict(fail);
+ }
+ setverdict(pass);
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+type integer Byte (-128 .. 127) with { variant "8 bit" };
+
+// Just to compile: the head of the select union is a complicated expression
+//function f_select_union_different_codegen(in anytype p_msg, out integer result) {
+// var Messages arr[1];
+// var Messages myMessage;
+// myMessage.msg1 := 1;
+// arr := { myMessage };
+// var Byte x := 11;
+// select union (arr[f_return_1(encvalue_unichar(x, "UTF-8"))]) {
+// case (msg1) { result := 1; }
+// case (msg2, msg3) { result := 2; }
+// case (msg4) { result := 3; }
+// }
+//}
+
+function f_return_1(in universal charstring str) return integer {
+ return 1;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+control {
+ execute(tc_SelectUnionWithoutElse());
+ execute(tc_SelectUnionWithElse());
+ execute(tc_SelectUnionAnyType());
+ execute(tc_SelectUnionMultipleBranches());
+ execute(tc_SelectUnionMultipleBranchesAnyType());
+}
+}
+
+
+with {
+ extension "anytype integer, bitstring"
+ extension "anytype charstring, boolean, octetstring"
+ extension "anytype Messages"
+ encode "RAW";
+}
\ No newline at end of file
diff --git a/Regression_Test_java/src/TanytypeOper.ttcn b/Regression_Test_java/src/TanytypeOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..73683a840e61895e2cf43b2c15e31c6413521f45
--- /dev/null
+++ b/Regression_Test_java/src/TanytypeOper.ttcn
@@ -0,0 +1,740 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ * Szabados, Kristof
+ *
+ ******************************************************************************/
+module TanytypeOper {
+// ********** Type definitions *********************
+type component anytypeOper_mycomp {};
+type enumerated anytypeOper_myenum {xx1,xx2,xx3};
+type record anytypeOper_trecord {
+ integer x1 optional,
+ float x2 };
+type record of octetstring anytypeOper_trecof;
+type set anytypeOper_tset {
+ integer x1,
+ float x2 optional };
+type set of charstring anytypeOper_tsetof;
+
+type union anytypeOper_tunion {
+ integer x1,
+ float x2 };
+
+type integer int;
+
+
+
+
+
+
+
+
+
+
+
+
+
+// *************** Constanst ***********************
+//const anytypeOper_trecord anytypeOper_temp1:={ x1:=omit, x2:=3.4 };
+//const anytypeOper_trecof anytypeOper_temp2:={ 'AF12'O };
+//const anytypeOper_tset anytypeOper_temp3:={ x1:=234, x2:=1.9};
+//const anytypeOper_tsetof anytypeOper_temp4:={"f","8"};
+//const anytypeOper_tunion anytypeOper_temp5:={ x2:=1.3 };
+const anytype anytypeOper_const1:=
+{ integer := 1 }; //union with basic types
+
+const anytype anytypeOper_const2:= { //union with enum
+ anytypeOper_myenum := xx1 };
+
+const anytype anytypeOper_const3:= { //union from record
+ anytypeOper_trecord := { x1:=1, x2:=1.2 } } ;
+
+const anytype anytypeOper_const4:={ //union from record of
+ anytypeOper_trecof := { '12AB'O, 'CD12'O } };
+
+const anytype anytypeOper_const5:={ //union from set
+ anytypeOper_tset :={ x1:=2, x2:=1.3} };
+
+const anytype anytypeOper_const6:={ //union from set of
+ anytypeOper_tsetof := {"a","b"} };
+
+const anytype anytypeOper_const7:={ //union from union
+ anytypeOper_tunion :={ x1 :=3 } } ;
+
+testcase anytypeAssign() runs on anytypeOper_mycomp{
+var anytype x1:={ //union with basic types
+ integer:=1 };
+var anytype x2,x3;
+x2:={ float:=1.2 };
+if (x1.integer==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (ischosen(x1.integer)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.float))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.float==1.2) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (ischosen(x2.float)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeAssignEnum() runs on anytypeOper_mycomp{
+var anytype x1:={ //union with enum
+ anytypeOper_myenum:=xx1};
+var anytype x2;
+x2:={ anytypeOper_myenum:=xx2 };
+if (x1.anytypeOper_myenum==xx1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_myenum)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.anytypeOper_myenum==xx2) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (ischosen(x2.anytypeOper_myenum)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeAssignRec() runs on anytypeOper_mycomp{
+//var anytypeOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var anytype x1:={ //union from record
+ anytypeOper_trecord:={ x1:=1, x2:=1.2 } };
+var anytype x2;
+x2:={ anytypeOper_trecord:={ x1:=1, x2:=1.2 } };
+if (x1.anytypeOper_trecord.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.anytypeOper_trecord.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_trecord)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.anytypeOper_trecord.x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.anytypeOper_trecord.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.anytypeOper_trecord)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeAssignRecof() runs on anytypeOper_mycomp{
+//var anytypeOper_trecof temp2:={'AF12'O};
+var anytype x1:={ //union from record of
+ anytypeOper_trecof := { '12AB'O, 'CD12'O } };
+var anytype x2;
+x2:={ anytypeOper_trecof:={ '12AB'O, 'CD12'O } };
+if (x1.anytypeOper_trecof[0]=='12AB'O) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.anytypeOper_trecof[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_trecof)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.anytypeOper_trecof[0]=='12AB'O) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.anytypeOper_trecof[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.anytypeOper_trecof)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase anytypeAssignSet() runs on anytypeOper_mycomp{
+//var anytypeOper_tset temp1:={ x1:=2, x2:=omit };
+var anytype x1:={ //union from record
+ anytypeOper_tset:={ x1:=1, x2:=1.2 } };
+var anytype x2;
+x2:={ anytypeOper_tset:={ x1:=1, x2:=1.2 } };
+if (x1.anytypeOper_tset.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.anytypeOper_tset.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_tset)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.anytypeOper_tset.x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.anytypeOper_tset.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.anytypeOper_tset)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeAssignSetof() runs on anytypeOper_mycomp{
+//var anytypeOper_tsetof temp2:={"a","7"};
+var anytype x1:={ //union from set of
+ anytypeOper_tsetof:={ "1", "a" } };
+var anytype x2;
+x2:={ anytypeOper_tsetof:={ "1", "a" } };
+if (x1.anytypeOper_tsetof[0]=="1") {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.anytypeOper_tsetof[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_tsetof)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.anytypeOper_tsetof[0]=="1") {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.anytypeOper_tsetof[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.anytypeOper_tsetof)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeAssignUnion() runs on anytypeOper_mycomp{
+//var anytypeOper_tunion temp5 := {x2:=1.3}
+var anytype x1:={ //union from union
+ anytypeOper_tunion:={ x1 :=3 } };
+var anytype x2;
+x2:={ anytypeOper_tunion:={ x1 :=3 } };
+if (x1.anytypeOper_tunion.x1==3) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_tunion.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.anytypeOper_tunion.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_tunion)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.anytypeOper_tunion.x1==3) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (ischosen(x2.anytypeOper_tunion.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.anytypeOper_tunion.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.anytypeOper_tunion)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeAssignElem() runs on anytypeOper_mycomp{
+var anytype x1, x2; //union with basic types
+x1:={ integer:=1 };
+x2:= {integer:=2}
+x1.integer:=3; // change value
+x2.float:=3.2; //choose other
+if (x1.integer==3) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (ischosen(x1.integer)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.float))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.float==3.2) {setverdict(pass);} //choose other
+ else {setverdict(fail);}
+if (ischosen(x2.float)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeAssignElemEnum() runs on anytypeOper_mycomp{
+var anytype x1, x2; //union with enum
+x1:={ anytypeOper_myenum:=xx1 };
+x2:= {anytypeOper_myenum:=xx2}
+x1.anytypeOper_myenum:=xx3; // change value
+x2.integer:=3; //choose other
+if (x1.anytypeOper_myenum==xx3) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_myenum)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.integer==3) {setverdict(pass);} //choose other
+ else {setverdict(fail);}
+if (ischosen(x2.integer)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.anytypeOper_myenum))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeAssignElemRec() runs on anytypeOper_mycomp{
+//var anytypeOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var anytype x1,x2; //union from record
+x1:={ anytypeOper_trecord:={ x1:=1, x2:=1.2 } };
+x2:={ anytypeOper_trecord:={ x1:=1, x2:=1.2 } };
+x1.anytypeOper_trecord.x1:=2; //change value
+x2.integer:=2; //change selection
+if (x1.anytypeOper_trecord.x1==2) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (x1.anytypeOper_trecord.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_trecord)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.integer==2) {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (ischosen(x2.integer)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.anytypeOper_trecord))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeAssignElemRecof() runs on anytypeOper_mycomp{
+//var anytypeOper_trecof temp2:={'AF12'O};
+var anytype x1,x2; //union from record of
+x1:={ anytypeOper_trecof:={ '12AB'O, 'CD12'O } };
+x2:={ anytypeOper_trecof:={ '12AB'O, 'CD12'O } };
+x1.anytypeOper_trecof[1]:='34AB'O; //change value
+x2.integer:=2; //change selection
+if (x1.anytypeOper_trecof[0]=='12AB'O) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (x1.anytypeOper_trecof[1]=='34AB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_trecof)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.integer==2) {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (ischosen(x2.integer)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.anytypeOper_trecof))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase anytypeAssignElemSet() runs on anytypeOper_mycomp{
+//var anytypeOper_tset temp1:={ x1:=2, x2:=omit };
+var anytype x1,x2; //union from record
+x1:= { anytypeOper_tset:={ x1:=1, x2:=1.2 } };
+x2:= { anytypeOper_tset:={ x1:=1, x2:=1.2 } };
+x1.anytypeOper_tset.x2:=3.4; //change value
+x2.integer:=3; //change selection
+if (x1.anytypeOper_tset.x1==1) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (x1.anytypeOper_tset.x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_tset)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.integer==3) {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (ischosen(x2.integer)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.anytypeOper_tset))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeAssignElemSetof() runs on anytypeOper_mycomp{
+//var anytypeOper_tsetof temp2:={"a","7"};
+var anytype x1,x2; //union from record of
+x1:={ anytypeOper_tsetof:={ "1", "a" } };
+x2:={ integer:=1 };
+x1.anytypeOper_tsetof[0]:="h"; //change value
+x2.anytypeOper_tsetof:={ "1", "a" }; //change selection
+if (x1.anytypeOper_tsetof[0]=="h") {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (x1.anytypeOper_tsetof[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_tsetof)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.anytypeOper_tsetof[0]=="1") {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (x2.anytypeOper_tsetof[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.anytypeOper_tsetof)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeAssignElemUnion() runs on anytypeOper_mycomp{
+//var anytypeOper_tunion temp5 := {x2:=1.3}
+var anytype x1,x2; //union from union
+x1:={ anytypeOper_tunion:={ x1 :=3 } };
+x2:={ integer:=2 };
+x1.anytypeOper_tunion.x2:=3.4; //change value
+x2.anytypeOper_tunion:={ x2 :=3.4 }; //change selection
+if (x1.anytypeOper_tunion.x2==3.4) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_tunion.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.anytypeOper_tunion.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeOper_tunion)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.anytypeOper_tunion.x2==3.4) {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (ischosen(x2.anytypeOper_tunion.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.anytypeOper_tunion.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.anytypeOper_tunion)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase anytypeConst() runs on anytypeOper_mycomp{
+const anytype const1:={ //union with basic types
+ integer:=1 };
+if (anytypeOper_const1.integer==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (ischosen(anytypeOper_const1.integer)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeOper_const1.float))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1.integer==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (ischosen(const1.integer)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const1.float))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeConstEnum() runs on anytypeOper_mycomp{
+const anytype const2:={ //union with enum
+ anytypeOper_myenum:=xx1} ;
+if (anytypeOper_const2.anytypeOper_myenum==xx1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (ischosen(anytypeOper_const2.anytypeOper_myenum)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeOper_const2.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const2.anytypeOper_myenum==xx1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (ischosen(const2.anytypeOper_myenum)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const2.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeConstRec() runs on anytypeOper_mycomp{
+const anytype const3:={ //union from record
+ anytypeOper_trecord:={ x1:=1, x2:=1.2 } } ;
+if (anytypeOper_const3.anytypeOper_trecord.x1==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (anytypeOper_const3.anytypeOper_trecord.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(anytypeOper_const3.anytypeOper_trecord)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeOper_const3.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const3.anytypeOper_trecord.x1==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const3.anytypeOper_trecord.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const3.anytypeOper_trecord)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const3.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeConstRecof() runs on anytypeOper_mycomp{
+const anytype const4:={ //union from record of
+ anytypeOper_trecof :={ '12AB'O, 'CD12'O } } ;
+if (anytypeOper_const4.anytypeOper_trecof[0]=='12AB'O) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (anytypeOper_const4.anytypeOper_trecof[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(anytypeOper_const4.anytypeOper_trecof)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeOper_const4.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const4.anytypeOper_trecof[0]=='12AB'O) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const4.anytypeOper_trecof[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const4.anytypeOper_trecof)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const4.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase anytypeConstSet() runs on anytypeOper_mycomp{
+const anytype const5:={ //union from set
+ anytypeOper_tset :={ x1:=2, x2:=1.3} };
+if (anytypeOper_const5.anytypeOper_tset.x1==2) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (anytypeOper_const5.anytypeOper_tset.x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(anytypeOper_const5.anytypeOper_tset)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeOper_const5.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const5.anytypeOper_tset.x1==2) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const5.anytypeOper_tset.x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const5.anytypeOper_tset)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const5.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeConstSetof() runs on anytypeOper_mycomp{
+const anytype const6:={ //union from set of
+ anytypeOper_tsetof :={"a","b"} };
+if (anytypeOper_const6.anytypeOper_tsetof[0]=="a") {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (anytypeOper_const6.anytypeOper_tsetof[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(anytypeOper_const6.anytypeOper_tsetof)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeOper_const6.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const6.anytypeOper_tsetof[0]=="a") {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const6.anytypeOper_tsetof[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const6.anytypeOper_tsetof)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const6.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeConstUnion() runs on anytypeOper_mycomp{
+const anytype const7:={ //union from union
+ anytypeOper_tunion:={ x1 :=3 } };
+if (anytypeOper_const7.anytypeOper_tunion.x1==3) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (ischosen(anytypeOper_const7.anytypeOper_tunion.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeOper_const7.anytypeOper_tunion.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(anytypeOper_const7.anytypeOper_tunion)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeOper_const7.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const7.anytypeOper_tunion.x1==3) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (ischosen(const7.anytypeOper_tunion.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const7.anytypeOper_tunion.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const7.anytypeOper_tunion)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const7.integer))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeComp() runs on anytypeOper_mycomp{
+var anytype x1,x2,x3,x4;
+x1:={ integer:=1 };
+x2:={ integer:=1 };
+x3:={ integer:=2 }; // different value
+x4:={ float:=1.2 }; // different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+testcase anytypeCompSame() runs on anytypeOper_mycomp{
+var anytype x1,x2;
+x1:={ integer:=1 }; // same value, different selection
+x2:={ int:=1 };
+if (x1!=x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypeCompEnum() runs on anytypeOper_mycomp{
+var anytype x1,x2,x3,x4;
+x1:={ anytypeOper_myenum:=xx1 };
+x2:={ anytypeOper_myenum:=xx1 };
+x3:={ anytypeOper_myenum:=xx2 }; // different value
+x4:={ integer:=1 }; // different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+
+testcase anytypeCompRec() runs on anytypeOper_mycomp{
+//var anytypeOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var anytype x1,x2,x3,x4;
+x1 :={ anytypeOper_trecord:={ x1:=1, x2:=1.2 } };
+x2 :={ anytypeOper_trecord:={ x1:=1, x2:=1.2 } };
+x3 :={ anytypeOper_trecord:={ x1:=2, x2:=1.2 } }; // different value
+x4 :={ integer:=1 }; // different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+
+testcase anytypeCompRecof() runs on anytypeOper_mycomp{
+//var anytypeOper_trecof temp2:={'AF12'O};
+var anytype x1,x2,x3,x4; //union from record of
+x1:={ anytypeOper_trecof:={ '12AB'O, 'CD12'O } };
+x2:={ anytypeOper_trecof:={ '12AB'O, 'CD12'O } };
+x3:={ anytypeOper_trecof:={ '12AB'O } }; //different value
+x4:={ integer:=12 }; //different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+
+testcase anytypeCompSet() runs on anytypeOper_mycomp{
+//var anytypeOper_tset temp1:={ x1:=2, x2:=omit };
+var anytype x1,x2,x3,x4; // union from set
+x1:={ anytypeOper_tset:={ x1:=1, x2:=1.2 } };
+x2:={ anytypeOper_tset:={ x1:=1, x2:=1.2 } };
+x3:={ anytypeOper_tset:={ x1:=4, x2:=1.2 } }; // different value
+x4:={ integer:=4 }; // different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+testcase anytypeCompSetof() runs on anytypeOper_mycomp{
+//var anytypeOper_tsetof temp2:={"a","7"};
+var anytype x1,x2,x3,x4; //union from record of
+x1:={ anytypeOper_tsetof:={ "1", "a" } };
+x2:={ anytypeOper_tsetof:={ "1", "a" } };
+x3:={ anytypeOper_tsetof:={ "1", "a", "k" } }; //different value
+x4:={ integer:=2 }; //different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+testcase anytypeCompUnion() runs on anytypeOper_mycomp{
+//var anytypeOper_tunion temp5 := {x2:=1.3}
+var anytype x1,x2,x3,x4; // union form union
+x1:={ anytypeOper_tunion:={ x1 :=3 } };
+x2:={ anytypeOper_tunion:={ x1 :=3 } };
+x3:={ anytypeOper_tunion:={ x2 :=3.9 } }; //different value
+x4:={ integer:=3 }; //different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+
+control {
+ execute(anytypeAssign());
+ execute(anytypeAssignEnum());
+ execute(anytypeAssignRec());
+ execute(anytypeAssignRecof());
+ execute(anytypeAssignSet());
+ execute(anytypeAssignSetof());
+ execute(anytypeAssignUnion());
+ execute(anytypeAssignElem());
+ execute(anytypeAssignElemEnum());
+ execute(anytypeAssignElemRec());
+ execute(anytypeAssignElemRecof());
+ execute(anytypeAssignElemSet());
+ execute(anytypeAssignElemSetof());
+ execute(anytypeAssignElemUnion());
+ execute(anytypeConst());
+ execute(anytypeConstEnum());
+ execute(anytypeConstRec());
+ execute(anytypeConstRecof());
+ execute(anytypeConstSet());
+ execute(anytypeConstSetof());
+ execute(anytypeConstUnion())
+ execute(anytypeComp());
+ execute(anytypeCompSame());
+ execute(anytypeCompEnum());
+ execute(anytypeCompRec());
+ execute(anytypeCompRecof());
+ execute(anytypeCompSet());
+ execute(anytypeCompSetof());
+ execute(anytypeCompUnion())
+}
+}
+with {
+extension "anytype int, integer, float, anytypeOper_tunion, anytypeOper_myenum"
+extension "anytype anytypeOper_trecord, anytypeOper_trecof"
+extension "anytype anytypeOper_tset, anytypeOper_tsetof"
+}
+
diff --git a/Regression_Test_java/src/TanytypeWrapOper.ttcn b/Regression_Test_java/src/TanytypeWrapOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..d2a7ba751a8d6a339c0476112ed4dd0929ebf3f6
--- /dev/null
+++ b/Regression_Test_java/src/TanytypeWrapOper.ttcn
@@ -0,0 +1,748 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ * Szabados, Kristof
+ *
+ ******************************************************************************/
+module TanytypeWrapOper {
+// ********** Type definitions *********************
+type component anytypeWrapOper_mycomp {};
+type enumerated anytypeWrapOper_myenum {xx1,xx2,xx3};
+type record anytypeWrapOper_trecord {
+ integer x1 optional,
+ float x2 };
+type record of octetstring anytypeWrapOper_trecof;
+type set anytypeWrapOper_tset {
+ integer x1,
+ float x2 optional };
+type set of charstring anytypeWrapOper_tsetof;
+
+type union anytypeWrapOper_tunion {
+ integer x1,
+ float x2 };
+type union anytypeWrapOper_myunion1 {integer x1, float x2}; // union of basic types
+type union anytypeWrapOper_myunion2 { // union of enum
+ anytypeWrapOper_myenum x1,
+ integer x2};
+type union anytypeWrapOper_myunion3 { // union of record
+ anytypeWrapOper_trecord x1,
+ integer x2};
+type union anytypeWrapOper_myunion4 { // union of record of
+ anytypeWrapOper_trecof x1,
+ integer x2};
+type union anytypeWrapOper_myunion5 { // union of set
+ anytypeWrapOper_tset x1,
+ integer x2};
+type union anytypeWrapOper_myunion6 { // union of set of
+ anytypeWrapOper_tsetof x1,
+ integer x2};
+type union anytypeWrapOper_myunion7 { // union of union
+ anytypeWrapOper_tunion x1,
+ integer x2};
+type union anytypeWrapOper_myunion8 { // union of same types
+ integer x1,
+ integer x2};
+
+// *************** Constanst ***********************
+//const anytypeWrapOper_trecord anytypeWrapOper_temp1:={ x1:=omit, x2:=3.4 };
+//const anytypeWrapOper_trecof anytypeWrapOper_temp2:={ 'AF12'O };
+//const anytypeWrapOper_tset anytypeWrapOper_temp3:={ x1:=234, x2:=1.9};
+//const anytypeWrapOper_tsetof anytypeWrapOper_temp4:={"f","8"};
+//const anytypeWrapOper_tunion anytypeWrapOper_temp5:={ x2:=1.3 };
+const anytype anytypeWrapOper_const1:=
+{ anytypeWrapOper_myunion1 := { x1:=1 } }; //union with basic types
+
+const anytype anytypeWrapOper_const2:= { anytypeWrapOper_myunion2 := { //union with enum
+ x1:=xx1 }};
+
+const anytype anytypeWrapOper_const3:= { anytypeWrapOper_myunion3 := { //union from record
+ x1:={ x1:=1, x2:=1.2 } } };
+
+const anytype anytypeWrapOper_const4:={ //union from record of
+ anytypeWrapOper_myunion4 := { x1:={ '12AB'O, 'CD12'O } } };
+
+const anytype anytypeWrapOper_const5:={ //union from set
+ anytypeWrapOper_myunion5 := { x1:={ x1:=2, x2:=1.3} } };
+
+const anytype anytypeWrapOper_const6:={ //union from set of
+ anytypeWrapOper_myunion6 := { x1:={"a","b"} } };
+
+const anytype anytypeWrapOper_const7:={ //union from union
+ anytypeWrapOper_myunion7 := { x1:={ x1 :=3 } } };
+
+testcase anytypewrapAssign() runs on anytypeWrapOper_mycomp{
+var anytype x1:={ //union with basic types
+ anytypeWrapOper_myunion1 := { x1:=1} };
+var anytypeWrapOper_myunion1 x2,x3;
+x2:={ x2:=1.2 };
+if (x1.anytypeWrapOper_myunion1.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (ischosen(x1.anytypeWrapOper_myunion1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.anytypeWrapOper_myunion1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==1.2) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (ischosen(x2.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapAssignEnum() runs on anytypeWrapOper_mycomp{
+var anytypeWrapOper_myunion2 x1:={ //union with enum
+ x1:=xx1};
+var anytypeWrapOper_myunion2 x2;
+x2:={ x1:=xx2 };
+if (x1.x1==xx1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1==xx2) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapAssignRec() runs on anytypeWrapOper_mycomp{
+//var anytypeWrapOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var anytypeWrapOper_myunion3 x1:={ //union from record
+ x1:={ x1:=1, x2:=1.2 } };
+var anytypeWrapOper_myunion3 x2;
+x2:={ x1:={ x1:=1, x2:=1.2 } };
+if (x1.x1.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapAssignRecof() runs on anytypeWrapOper_mycomp{
+//var anytypeWrapOper_trecof temp2:={'AF12'O};
+var anytypeWrapOper_myunion4 x1:={ //union from record of
+ x1:={ '12AB'O, 'CD12'O } };
+var anytypeWrapOper_myunion4 x2;
+x2:={ x1:={ '12AB'O, 'CD12'O } };
+if (x1.x1[0]=='12AB'O) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1[0]=='12AB'O) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase anytypewrapAssignSet() runs on anytypeWrapOper_mycomp{
+//var anytypeWrapOper_tset temp1:={ x1:=2, x2:=omit };
+var anytypeWrapOper_myunion5 x1:={ //union from record
+ x1:={ x1:=1, x2:=1.2 } };
+var anytypeWrapOper_myunion5 x2;
+x2:={ x1:={ x1:=1, x2:=1.2 } };
+if (x1.x1.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapAssignSetof() runs on anytypeWrapOper_mycomp{
+//var anytypeWrapOper_tsetof temp2:={"a","7"};
+var anytypeWrapOper_myunion6 x1:={ //union from set of
+ x1:={ "1", "a" } };
+var anytypeWrapOper_myunion6 x2;
+x2:={ x1:={ "1", "a" } };
+if (x1.x1[0]=="1") {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1[0]=="1") {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapAssignUnion() runs on anytypeWrapOper_mycomp{
+var anytypeWrapOper_tunion temp5 := {x2:=1.3}
+var anytypeWrapOper_myunion7 x1:={ //union from union
+ x1:={ x1 :=3 } };
+var anytypeWrapOper_myunion7 x2;
+x2:={ x1:={ x1 :=3 } };
+if (x1.x1.x1==3) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (ischosen(x1.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x1==3) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (ischosen(x2.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapAssignElem() runs on anytypeWrapOper_mycomp{
+var anytypeWrapOper_myunion1 x1, x2; //union with basic types
+x1:={ x1:=1 };
+x2:= {x1:=2}
+x1.x1:=3; // change value
+x2.x2:=3.2; //choose other
+if (x1.x1==3) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==3.2) {setverdict(pass);} //choose other
+ else {setverdict(fail);}
+if (ischosen(x2.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapAssignElemEnum() runs on anytypeWrapOper_mycomp{
+var anytypeWrapOper_myunion2 x1, x2; //union with enum
+x1:={ x1:=xx1 };
+x2:= {x1:=xx2}
+x1.x1:=xx3; // change value
+x2.x2:=3; //choose other
+if (x1.x1==xx3) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==3) {setverdict(pass);} //choose other
+ else {setverdict(fail);}
+if (ischosen(x2.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapAssignElemRec() runs on anytypeWrapOper_mycomp{
+//var anytypeWrapOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var anytypeWrapOper_myunion3 x1,x2; //union from record
+x1:={ x1:={ x1:=1, x2:=1.2 } };
+x2:={ x1:={ x1:=1, x2:=1.2 } };
+x1.x1.x1:=2; //change value
+x2.x2:=2; //change selection
+if (x1.x1.x1==2) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (x1.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==2) {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (ischosen(x2.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapAssignElemRecof() runs on anytypeWrapOper_mycomp{
+//var anytypeWrapOper_trecof temp2:={'AF12'O};
+var anytypeWrapOper_myunion4 x1,x2; //union from record of
+x1:={ x1:={ '12AB'O, 'CD12'O } };
+x2:={ x1:={ '12AB'O, 'CD12'O } };
+x1.x1[1]:='34AB'O; //change value
+x2.x2:=2; //change selection
+if (x1.x1[0]=='12AB'O) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (x1.x1[1]=='34AB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==2) {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (ischosen(x2.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase anytypewrapAssignElemSet() runs on anytypeWrapOper_mycomp{
+//var anytypeWrapOper_tset temp1:={ x1:=2, x2:=omit };
+var anytypeWrapOper_myunion5 x1,x2; //union from record
+x1:= { x1:={ x1:=1, x2:=1.2 } };
+x2:= { x1:={ x1:=1, x2:=1.2 } };
+x1.x1.x2:=3.4; //change value
+x2.x2:=3; //change selection
+if (x1.x1.x1==1) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (x1.x1.x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==3) {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (ischosen(x2.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapAssignElemSetof() runs on anytypeWrapOper_mycomp{
+//var anytypeWrapOper_tsetof temp2:={"a","7"};
+var anytypeWrapOper_myunion6 x1,x2; //union from record of
+x1:={ x1:={ "1", "a" } };
+x2:={ x2:=1 };
+x1.x1[0]:="h"; //change value
+x2.x1:={ "1", "a" }; //change selection
+if (x1.x1[0]=="h") {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (x1.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1[0]=="1") {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (x2.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapAssignElemUnion() runs on anytypeWrapOper_mycomp{
+//var anytypeWrapOper_tunion temp5 := {x2:=1.3}
+var anytypeWrapOper_myunion7 x1,x2; //union from union
+x1:={ x1:={ x1 :=3 } };
+x2:={ x2:=2 };
+x1.x1.x2:=3.4; //change value
+x2.x1:={ x2 :=3.4 }; //change selection
+if (x1.x1.x2==3.4) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (ischosen(x1.x1.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x1.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x2==3.4) {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (ischosen(x2.x1.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase anytypewrapConst() runs on anytypeWrapOper_mycomp{
+const anytype const1:={ //union with basic types
+ anytypeWrapOper_myunion1 := { x1:=1 } };
+if (anytypeWrapOper_const1.anytypeWrapOper_myunion1.x1==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (ischosen(anytypeWrapOper_const1.anytypeWrapOper_myunion1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeWrapOper_const1.anytypeWrapOper_myunion1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1.anytypeWrapOper_myunion1.x1==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (ischosen(const1.anytypeWrapOper_myunion1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const1.anytypeWrapOper_myunion1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapConstEnum() runs on anytypeWrapOper_mycomp{
+const anytype const2:={ //union with enum
+ anytypeWrapOper_myunion2 := {x1:=xx1} };
+if (anytypeWrapOper_const2.anytypeWrapOper_myunion2.x1==xx1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (ischosen(anytypeWrapOper_const2.anytypeWrapOper_myunion2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeWrapOper_const2.anytypeWrapOper_myunion2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const2.anytypeWrapOper_myunion2.x1==xx1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (ischosen(const2.anytypeWrapOper_myunion2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const2.anytypeWrapOper_myunion2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapConstRec() runs on anytypeWrapOper_mycomp{
+const anytype const3:={ //union from record
+ anytypeWrapOper_myunion3 := { x1:={ x1:=1, x2:=1.2 } } };
+if (anytypeWrapOper_const3.anytypeWrapOper_myunion3.x1.x1==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (anytypeWrapOper_const3.anytypeWrapOper_myunion3.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(anytypeWrapOper_const3.anytypeWrapOper_myunion3.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeWrapOper_const3.anytypeWrapOper_myunion3.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const3.anytypeWrapOper_myunion3.x1.x1==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const3.anytypeWrapOper_myunion3.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const3.anytypeWrapOper_myunion3.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const3.anytypeWrapOper_myunion3.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapConstRecof() runs on anytypeWrapOper_mycomp{
+const anytype const4:={ //union from record of
+ anytypeWrapOper_myunion4 := { x1:={ '12AB'O, 'CD12'O } } };
+if (anytypeWrapOper_const4.anytypeWrapOper_myunion4.x1[0]=='12AB'O) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (anytypeWrapOper_const4.anytypeWrapOper_myunion4.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(anytypeWrapOper_const4.anytypeWrapOper_myunion4.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeWrapOper_const4.anytypeWrapOper_myunion4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const4.anytypeWrapOper_myunion4.x1[0]=='12AB'O) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const4.anytypeWrapOper_myunion4.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const4.anytypeWrapOper_myunion4.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const4.anytypeWrapOper_myunion4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase anytypewrapConstSet() runs on anytypeWrapOper_mycomp{
+const anytype const5:={ //union from set
+ anytypeWrapOper_myunion5 := { x1:={ x1:=2, x2:=1.3} } };
+if (anytypeWrapOper_const5.anytypeWrapOper_myunion5.x1.x1==2) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (anytypeWrapOper_const5.anytypeWrapOper_myunion5.x1.x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(anytypeWrapOper_const5.anytypeWrapOper_myunion5.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeWrapOper_const5.anytypeWrapOper_myunion5.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const5.anytypeWrapOper_myunion5.x1.x1==2) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const5.anytypeWrapOper_myunion5.x1.x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const5.anytypeWrapOper_myunion5.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const5.anytypeWrapOper_myunion5.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapConstSetof() runs on anytypeWrapOper_mycomp{
+const anytype const6:={ //union from set of
+ anytypeWrapOper_myunion6 := { x1:={"a","b"} } };
+if (anytypeWrapOper_const6.anytypeWrapOper_myunion6.x1[0]=="a") {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (anytypeWrapOper_const6.anytypeWrapOper_myunion6.x1[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(anytypeWrapOper_const6.anytypeWrapOper_myunion6.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeWrapOper_const6.anytypeWrapOper_myunion6.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const6.anytypeWrapOper_myunion6.x1[0]=="a") {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const6.anytypeWrapOper_myunion6.x1[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const6.anytypeWrapOper_myunion6.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const6.anytypeWrapOper_myunion6.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapConstUnion() runs on anytypeWrapOper_mycomp{
+const anytype const7:={ //union from union
+ anytypeWrapOper_myunion7 := { x1:={ x1 :=3 } } };
+if (anytypeWrapOper_const7.anytypeWrapOper_myunion7.x1.x1==3) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (ischosen(anytypeWrapOper_const7.anytypeWrapOper_myunion7.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeWrapOper_const7.anytypeWrapOper_myunion7.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(anytypeWrapOper_const7.anytypeWrapOper_myunion7.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(anytypeWrapOper_const7.anytypeWrapOper_myunion7.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const7.anytypeWrapOper_myunion7.x1.x1==3) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (ischosen(const7.anytypeWrapOper_myunion7.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const7.anytypeWrapOper_myunion7.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const7.anytypeWrapOper_myunion7.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const7.anytypeWrapOper_myunion7.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapComp() runs on anytypeWrapOper_mycomp{
+var anytypeWrapOper_myunion1 x1,x2,x3,x4;
+x1:={ x1:=1 };
+x2:={ x1:=1 };
+x3:={ x1:=2 }; // different value
+x4:={ x2:=1.2 }; // different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapCompSame() runs on anytypeWrapOper_mycomp{
+var anytypeWrapOper_myunion8 x1,x2;
+x1:={ x1:=1 }; // same value, different selection
+x2:={ x2:=1 };
+if (x1!=x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapCompEnum() runs on anytypeWrapOper_mycomp{
+var anytypeWrapOper_myunion2 x1,x2,x3,x4;
+x1:={ x1:=xx1 };
+x2:={ x1:=xx1 };
+x3:={ x1:=xx2 }; // different value
+x4:={ x2:=1 }; // different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+
+testcase anytypewrapCompRec() runs on anytypeWrapOper_mycomp{
+//var anytypeWrapOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var anytypeWrapOper_myunion3 x1,x2,x3,x4;
+x1 :={ x1:={ x1:=1, x2:=1.2 } };
+x2 :={ x1:={ x1:=1, x2:=1.2 } };
+x3 :={ x1:={ x1:=2, x2:=1.2 } }; // different value
+x4 :={ x2:=1 }; // different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+
+testcase anytypewrapCompRecof() runs on anytypeWrapOper_mycomp{
+//var anytypeWrapOper_trecof temp2:={'AF12'O};
+var anytypeWrapOper_myunion4 x1,x2,x3,x4; //union from record of
+x1:={ x1:={ '12AB'O, 'CD12'O } };
+x2:={ x1:={ '12AB'O, 'CD12'O } };
+x3:={ x1:={ '12AB'O } }; //different value
+x4:={ x2:=12 }; //different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+
+testcase anytypewrapCompSet() runs on anytypeWrapOper_mycomp{
+//var anytypeWrapOper_tset temp1:={ x1:=2, x2:=omit };
+var anytypeWrapOper_myunion5 x1,x2,x3,x4; // union from set
+x1:={ x1:={ x1:=1, x2:=1.2 } };
+x2:={ x1:={ x1:=1, x2:=1.2 } };
+x3:={ x1:={ x1:=4, x2:=1.2 } }; // different value
+x4:={ x2:=4 }; // different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapCompSetof() runs on anytypeWrapOper_mycomp{
+//var anytypeWrapOper_tsetof temp2:={"a","7"};
+var anytypeWrapOper_myunion6 x1,x2,x3,x4; //union from record of
+x1:={ x1:={ "1", "a" } };
+x2:={ x1:={ "1", "a" } };
+x3:={ x1:={ "1", "a", "k" } }; //different value
+x4:={ x2:=2 }; //different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+testcase anytypewrapCompUnion() runs on anytypeWrapOper_mycomp{
+var anytypeWrapOper_tunion temp5 := {x2:=1.3}
+var anytypeWrapOper_myunion7 x1,x2,x3,x4; // union form union
+x1:={ x1:={ x1 :=3 } };
+x2:={ x1:={ x1 :=3 } };
+x3:={ x1:={ x2 :=3.9 } }; //different value
+x4:={ x2:=3 }; //different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+
+control {
+ execute(anytypewrapAssign());
+ execute(anytypewrapAssignEnum());
+ execute(anytypewrapAssignRec());
+ execute(anytypewrapAssignRecof());
+ execute(anytypewrapAssignSet());
+ execute(anytypewrapAssignSetof());
+ execute(anytypewrapAssignUnion());
+ execute(anytypewrapAssignElem());
+ execute(anytypewrapAssignElemEnum());
+ execute(anytypewrapAssignElemRec());
+ execute(anytypewrapAssignElemRecof());
+ execute(anytypewrapAssignElemSet());
+ execute(anytypewrapAssignElemSetof());
+ execute(anytypewrapAssignElemUnion());
+ execute(anytypewrapConst());
+ execute(anytypewrapConstEnum());
+ execute(anytypewrapConstRec());
+ execute(anytypewrapConstRecof());
+ execute(anytypewrapConstSet());
+ execute(anytypewrapConstSetof());
+ execute(anytypewrapConstUnion())
+ execute(anytypewrapComp());
+ execute(anytypewrapCompSame());
+ execute(anytypewrapCompEnum());
+ execute(anytypewrapCompRec());
+ execute(anytypewrapCompRecof());
+ execute(anytypewrapCompSet());
+ execute(anytypewrapCompSetof());
+ execute(anytypewrapCompUnion())
+}
+}
+with {
+extension "anytype anytypeWrapOper_tunion, anytypeWrapOper_myunion1, anytypeWrapOper_myunion2"
+extension "anytype anytypeWrapOper_myunion3, anytypeWrapOper_myunion4, anytypeWrapOper_myunion5"
+extension "anytype anytypeWrapOper_myunion6, anytypeWrapOper_myunion7, anytypeWrapOper_myunion8"
+}
+
diff --git a/Regression_Test_java/src/TarrayOper.ttcn b/Regression_Test_java/src/TarrayOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..095ad53e39fee3763e1c39345b99f166138b60b2
--- /dev/null
+++ b/Regression_Test_java/src/TarrayOper.ttcn
@@ -0,0 +1,966 @@
+/******************************************************************************
+ * 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
+ * Beres, Szabolcs
+ * Cserveni, Akos
+ * Forstner, Matyas
+ * Godar, Marton
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ * Pandi, Krisztian
+ *
+ ******************************************************************************/
+module TarrayOper {
+// ********** Type definitions *********************
+type component arrayOper_mycomp {};
+type enumerated arrayOper_myenum {xx1,xx2,xx3};
+type record arrayOper_trecord {
+ integer x1 optional,
+ float x2 };
+type record of octetstring arrayOper_trecof;
+type set arrayOper_tset {
+ integer x1,
+ float x2 optional };
+type set of charstring arrayOper_tsetof;
+type set of integer arrayOper_tsetof2;
+type union arrayOper_tunion {
+ integer x1,
+ float x2 };
+type arrayOper_tsetof2 arrayOper_triplet[3];
+type arrayOper_triplet arrayOper_triplettriplet[3];
+type record arrayOper_trecord2{
+ integer x1[3]
+};
+// *************** Constanst ***********************
+const arrayOper_trecord arrayOper_temp1:={ x1:=omit, x2:=3.4 };
+const arrayOper_trecof arrayOper_temp2:={ 'AF12'O };
+const arrayOper_tset arrayOper_temp3:={ x1:=234, x2:=1.9};
+const arrayOper_tsetof arrayOper_temp4:={"f","8"};
+const arrayOper_tunion arrayOper_temp5:={ x2:=1.3 };
+const integer arrayOper_const1[2]:={ 1,2 } //array of basic types
+const arrayOper_myenum arrayOper_const2[2]:={ xx2, xx1 }
+const arrayOper_trecord arrayOper_const4[2]:={ //array of record
+ { x1:=1, x2:=1.2 },arrayOper_temp1 };
+const arrayOper_trecof arrayOper_const6[2]:={ //array of record of
+ { '12AB'O, 'CD12'O }, arrayOper_temp2 };
+const arrayOper_tset arrayOper_const8[2]:={ //array of set
+ { x1:=2, x2:=1.3}, arrayOper_temp3 };
+const arrayOper_tsetof arrayOper_const10[2]:={ //array of set of
+ {"a","b"}, arrayOper_temp4 }; //{"f","8"},
+const arrayOper_tunion arrayOper_const12[2]:={ //array of union
+ { x1 :=3 }, arrayOper_temp5 }; //{ x2:=1.3 }
+const arrayOper_tsetof2 arrayOper_const13[3][3]:={
+{{1,2},{2,3},{3,4}},{{1,2},{4,5},{6,7}},{{2,1},{3,2},{4,3}}}
+
+
+
+testcase arrayAssign() runs on arrayOper_mycomp{
+var integer x1[2]:={ 12,34} //array of basic types
+var integer x2[2];
+var integer x3[2 .. 4]; //index ranges
+x2:={ 32, 12 };
+x3:={32,12,3};
+if (x1[0]==12) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1[1]==34) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0]==32) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2[1]==12) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3[2]==32) {setverdict(pass);} //index ranges
+ else {setverdict(fail);}
+if (x3[3]==12) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3[4]==3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignEnum() runs on arrayOper_mycomp{
+var arrayOper_myenum x1[2]:={ xx2, - } //array of enum
+var arrayOper_myenum x2[2];
+x2:={xx2,xx1};
+//at declaration
+if (x1[0]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+//later
+if (x2[0]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1]==xx1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignRec() runs on arrayOper_mycomp{
+var arrayOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var arrayOper_trecord x1[2]:={ //array of record
+ { x1:=1, x2:=1.2 }, temp1 };
+var arrayOper_trecord x2[2];
+x2:={ { x1:=1, x2:=1.2 }, temp1 };
+if (x1[0].x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1]==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0].x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1].x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignRecof() runs on arrayOper_mycomp{
+var arrayOper_trecof temp2:={'AF12'O};
+var arrayOper_trecof x1[2]:={ //array of record of
+ { '12AB'O, 'CD12'O }, temp2 };
+var arrayOper_trecof x2[2];
+x2:={ { '12AB'O, 'CD12'O }, temp2 };
+if (x1[0][0]=='12AB'O) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1]==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0][0]=='12AB'O) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1][0]=='AF12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignSet() runs on arrayOper_mycomp{
+var arrayOper_tset temp1:={ x1:=2, x2:=omit };
+var arrayOper_tset x1[2]:={ //array of set
+ { x1:=1, x2:=1.2 }, temp1 };
+var arrayOper_tset x2[2];
+x2:={ { x1:=1, x2:=1.2 }, temp1 };
+if (x1[0].x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1]==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0].x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1].x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2[1].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignSetof() runs on arrayOper_mycomp{
+var arrayOper_tsetof temp2:={"a","7"};
+var arrayOper_tsetof x1[2]:={ //array of set of
+ { "1", "a" }, temp2 };
+var arrayOper_tsetof x2[2];
+x2:={ { "1", "a" }, temp2 };
+if (x1[0][0]=="1") {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1[0][1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1]==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0][0]=="1") {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2[0][1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1][0]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1][1]=="7") {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignUnion() runs on arrayOper_mycomp{
+var arrayOper_tunion temp5 := {x2:=1.3}
+var arrayOper_tunion x1[2]:={ //array of union
+ { x1 :=3 }, temp5 }; //{ x2:=1.3
+var arrayOper_tunion x2[2];
+x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
+if (x1[0].x1==3) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (ischosen(x1[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1]==temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0].x1==3) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (ischosen(x2[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2[1].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignArray() runs on arrayOper_mycomp{
+var charstring x1[2][2]:={ //array of array
+ { "1", "a" }, {"a","7"} };
+var arrayOper_tsetof x2[2];
+x2:={ { "1", "a" }, {"a","7"} };
+if (x1[0][0]=="1") {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1[0][1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1][0]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1][1]=="7") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0][0]=="1") {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2[0][1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1][0]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1][1]=="7") {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignSubArray() runs on arrayOper_mycomp{
+ var integer x1[4][2] := {{1,2},{3,4},{5,6},{7,8}}; //array of basic types
+ var integer x2[2][2] := {x1[0],x1[3]};
+ var integer x3[1][2] := {{x1[0][0],x1[1][0]}};
+ if(x2[0][0]==1){setverdict(pass);}
+ else {setverdict(fail);}
+ if(x2[0][1]==2){setverdict(pass);}
+ else {setverdict(fail);}
+ if(x2[1][0]==7){setverdict(pass);}
+ else {setverdict(fail);}
+ if(x2[1][1]==8){setverdict(pass);}
+ else {setverdict(fail);}
+ if(x3[0][0]==1){setverdict(pass);}
+ else {setverdict(fail);}
+ if(x3[0][1]==3){setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignRangedArray() runs on arrayOper_mycomp{
+ var integer x1[1..2][2..3]:={{1,2},{2,3}};
+ var integer x2[0..1][2..3]:={{11,22},x1[1]};
+ if(x1[1][2]==1){setverdict(pass);}
+ else{setverdict(fail);}
+ if(x1[1][3]==2){setverdict(pass);}
+ else{setverdict(fail);}
+ if(x1[2][2]==2){setverdict(pass);}
+ else{setverdict(fail);}
+ if(x1[2][3]==3){setverdict(pass);}
+ else{setverdict(fail);}
+ if(x2[0][2]==11){setverdict(pass);}
+ else{setverdict(fail);}
+ if(x2[0][3]==22){setverdict(pass);}
+ else{setverdict(fail);}
+ if(x2[1][2]==1){setverdict(pass);}
+ else{setverdict(fail);}
+}
+
+testcase arrayAssignElem() runs on arrayOper_mycomp{
+var integer x1[2], x2[2], x3[2], x4[5] ; //array of basic types
+x1:={ 3, 2 };
+x2:={ 1, 2 };
+x3:=x2;
+x2[0]:=3; //change element to value
+x3[0]:=x2[0]; //change element to element
+x4[2]:=2; // out of order
+if (x1[1]==2) {setverdict(pass);} //accessing individual element
+ else {setverdict(fail);}
+if (x2[0]==3) {setverdict(pass);} // change element to value
+ else {setverdict(fail);}
+if (x2[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3[0]==3) {setverdict(pass);} // change element to element
+ else {setverdict(fail);}
+if (x3[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4[2]==2) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignElemEnum() runs on arrayOper_mycomp{
+var arrayOper_myenum x1[2],x2[3]; //array of enumerated
+x1:={ xx1, xx2 };
+x1[0]:=xx3; //change element
+x2[2]:=xx3; // out of order
+if (x1[0]==xx3) {setverdict(pass);} // change element
+ else {setverdict(fail);}
+if (x1[1]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[2]==xx3) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignElemRec() runs on arrayOper_mycomp{
+var arrayOper_trecord x1[2],x2[2]; //array of record
+x1:={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
+x1[0].x1:=2;
+x1[1].x1:=3;
+x2[1]:= {x1:=2, x2:=1.3}; //out of order
+if (x1[0].x1==2) {setverdict(pass);} // change element
+ else {setverdict(fail);}
+if (x1[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1].x1==3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1].x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1].x1==2) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+if (x2[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignElemRecof() runs on arrayOper_mycomp{
+var arrayOper_trecof x1[2],x2[3]; //record of record of
+x1:={ { '12AB'O, 'CD12'O }, { 'ABCD'O } };
+x1[0][1]:='34AB'O; //change element
+x2[2]:={'12CD'O}; //out of order
+if (x1[0][0]=='12AB'O) {setverdict(pass);} // change element
+ else {setverdict(fail);}
+if (x1[0][1]=='34AB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1][0]=='ABCD'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[2][0]=='12CD'O) {setverdict(pass);} //out of order
+ else {setverdict(fail);}}
+
+testcase arrayAssignElemSet() runs on arrayOper_mycomp{
+var arrayOper_tset x1[2],x2[3]; //array of set
+x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
+x1[0].x2:=3.4; //change element
+x2[2]:={ x1:=2, x2:=1.3 }; // out of order
+if (x1[0].x1==1) {setverdict(pass);} //change element
+ else {setverdict(fail);}
+if (x1[0].x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1].x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x1[1].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[2].x1==2) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+if (x2[2].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignElemSetof() runs on arrayOper_mycomp{
+var arrayOper_tsetof x1[2],x2[3]; //array of set of
+x1:={ { "1" }, {"a","7"}};
+x1[0][0]:="h"; // change element
+x2[2]:={"2"}; //out of order
+if (x1[0][0]=="h") {setverdict(pass);} //change element
+ else {setverdict(fail);}
+if (x1[1][0]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1][1]=="7") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[2][0]=="2") {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignElemUnion() runs on arrayOper_mycomp{
+//var arrayOper_tunion temp5 := {x2:=1.3}
+var arrayOper_tunion x1[2],x2[3]; //array of union
+x1:={ {x1 :=3 }, {x2:=1.3} };
+x1[0].x2:=3.4; //change element
+x2[2]:={ x2:=1.4}; // out of order
+if (x1[0].x2==3.4) {setverdict(pass);} //changed element
+ else {setverdict(fail);}
+if (ischosen(x1[0].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1[0].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1[1].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[2].x2==1.4) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+if (ischosen(x2[2].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2[2].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignSubArrayElem() runs on arrayOper_mycomp{
+ var integer x1[4][2]; //array of basic types
+ var integer x2[2][2];
+ var integer x3[1][2];
+ x1:={{1,2},{3,4},{5,6},{7,8}};
+ x2:={x1[0],x1[3]};
+ x3[0]:={x1[0][0],3};
+ if(x2[0][0]==1){setverdict(pass);}
+ else {setverdict(fail);}
+ if(x2[0][1]==2){setverdict(pass);}
+ else {setverdict(fail);}
+ if(x2[1][0]==7){setverdict(pass);}
+ else {setverdict(fail);}
+ if(x2[1][1]==8){setverdict(pass);}
+ else {setverdict(fail);}
+ if(x3[0][0]==1){setverdict(pass);}
+ else {setverdict(fail);}
+ if(x3[0][1]==3){setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayAssignRangedArrayElem() runs on arrayOper_mycomp{
+ var integer x1[1..2][2..3];
+ var integer x2[0..1][2..3];
+ x1:={{1,2},{2,3}};
+ x2:={{11,22},x1[1]};
+ if(x1[1][2]==1){setverdict(pass);}
+ else{setverdict(fail);}
+ if(x1[1][3]==2){setverdict(pass);}
+ else{setverdict(fail);}
+ if(x1[2][2]==2){setverdict(pass);}
+ else{setverdict(fail);}
+ if(x1[2][3]==3){setverdict(pass);}
+ else{setverdict(fail);}
+ if(x2[0][2]==11){setverdict(pass);}
+ else{setverdict(fail);}
+ if(x2[0][3]==22){setverdict(pass);}
+ else{setverdict(fail);}
+ if(x2[1][2]==1){setverdict(pass);}
+ else{setverdict(fail);}
+}
+
+testcase arrayConst() runs on arrayOper_mycomp{
+const integer const1[3]:={1,2,3} //array of basic types
+if (arrayOper_const1[0]==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (arrayOper_const1[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1[0]==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const1[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1[2]==3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayConstEnum() runs on arrayOper_mycomp{
+const arrayOper_myenum const1[3]:={xx1,xx2,xx3} //array of enumerated
+if (arrayOper_const2[0]==xx2) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (arrayOper_const2[1]==xx1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1[0]==xx1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const1[1]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1[2]==xx3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayConstRec() runs on arrayOper_mycomp{
+const arrayOper_trecord const4[2]:={ //array of record
+ { x1:=1, x2:=1.2 }, arrayOper_temp1 };
+if (arrayOper_const4[0].x1==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (arrayOper_const4[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (arrayOper_const4[1]==arrayOper_temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const4[0].x1==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const4[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const4[1]==arrayOper_temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayConstRecof() runs on arrayOper_mycomp{
+const arrayOper_trecof const6[2]:={ //array of record of
+ { '12AB'O, 'CD12'O }, arrayOper_temp2 };
+if (arrayOper_const6[0][0]=='12AB'O) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (arrayOper_const6[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (arrayOper_const6[1]==arrayOper_temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const6[0][0]=='12AB'O) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const6[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const6[1]==arrayOper_temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayConstSet() runs on arrayOper_mycomp{
+const arrayOper_tset const8[2]:={ //array of set
+ { x1:=2, x2:=1.3}, arrayOper_temp3 };
+if (arrayOper_const8[0].x1==2) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (arrayOper_const8[0].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (arrayOper_const8[1]==arrayOper_temp3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const8[0].x1==2) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const8[0].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const8[1]==arrayOper_temp3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayConstSetof() runs on arrayOper_mycomp{
+const arrayOper_tsetof const10[2]:={ //array of set of
+ {"a","b"}, {"f","8"} };
+if (arrayOper_const10[0][0]=="a") {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (arrayOper_const10[0][1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (arrayOper_const10[1]==arrayOper_temp4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const10[0][0]=="a") {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const10[0][1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (const10[1][0]=="f") {setverdict(pass);}
+ else {setverdict(fail);}
+if (const10[1][1]=="8") {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayConstUnion() runs on arrayOper_mycomp{
+const arrayOper_tunion const12[2]:={ //array of union
+ { x1 :=3 }, { x2:=1.3 } };
+if (arrayOper_const12[0].x1==3) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (ischosen(arrayOper_const12[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(arrayOper_const12[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (arrayOper_const12[1]==arrayOper_temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const12[0].x1==3) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (ischosen(const12[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const12[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const12[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const12[1].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const12[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayComp() runs on arrayOper_mycomp{
+var integer x1[3],x2[0..2],x3[3],x4[3],x5[4]; //array of basic type
+x1:={ 1,2,3 };
+x2:={ 1,2,3 };
+x3:={ 1,2,4 };
+x4:={3,2,1};
+x5:={1,2,3,-};
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x4)) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x4) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+}
+
+testcase arrayCompConst() runs on arrayOper_mycomp{ //In testcase definition//
+ const integer c_array1[4] := { 1,2,3,4};
+ const integer c_array2[4] := { 1,2,3,4};
+ const integer c_array3[4] := { 4,3,2,1};
+ const integer c_array4_ind[4] := { [0] := 1, [1] := 2, [2] := 3, [3] := 4};
+ const integer c_array5_ind[4] := { [3] := 4, [1] := 2, [2] := 3, [0] := 1};
+
+
+ var integer vl_array5[4] := { 1,2,3,4};
+
+
+ if(c_array1 == c_array1) {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
+
+ if({1,2,3,4} == c_array1) {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
+
+ if(c_array1 == c_array2) {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
+
+ if(c_array1 == c_array4_ind) {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
+
+ if(c_array4_ind == c_array4_ind) {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
+
+ if({ [0] := 1, [1] := 2, [2] := 3, [3] := 4} == c_array4_ind) {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
+
+ if(c_array4_ind == c_array5_ind) {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement\:$// //^warning: Control never reaches this code because of previous effective condition\(s\)$//
+
+
+ if(vl_array5 == c_array1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayCompEnum() runs on arrayOper_mycomp{
+var arrayOper_myenum x1[3],x2[3],x3[3]; // array of enum
+x1:={ xx1,xx2,xx3 };
+x2:={ xx1,xx2,xx3 };
+x3:={ xx1,xx2,xx2 };
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayCompRec() runs on arrayOper_mycomp{
+var arrayOper_trecord x1[2],x2[2],x3[2]; // array of record
+x1 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
+x2 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
+x3 :={ { x1:=2, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase arrayCompRecof() runs on arrayOper_mycomp{
+//var arrayOper_trecof temp2:={'AF12'O};
+var arrayOper_trecof x1[2],x2[2],x3[2]; //array of record of
+x1:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
+x2:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
+x3:={ { '12AB'O }, {'AF12'O} };
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase arrayCompSet() runs on arrayOper_mycomp{
+//var arrayOper_tset temp1:={ x1:=2, x2:=omit };
+var arrayOper_tset x1[2],x2[2],x3[2]; //array of set
+x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit } };
+x2:={ { x2:=1.2, x1:=1 }, { x1:=2, x2:=omit }};
+x3:={ { x1:=1, x2:=1.2 }, { x1:=1, x2:=1.2 } };
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x2==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayCompSetof() runs on arrayOper_mycomp{
+var arrayOper_tsetof temp2:={"a","7"};
+var arrayOper_tsetof x1[2],x2[2],x3[2]; //array of set of
+x1:={ { "1", "a" }, temp2 };
+x2:={ { "1", "a" }, {"a","7"} };
+x3:={ { "1", "a" }, {"l", "k"} };
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x2==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayCompUnion() runs on arrayOper_mycomp{
+var arrayOper_tunion temp5 := {x2:=1.3}
+var arrayOper_tunion x1[2],x2[2],x3[2]; //array of union
+x1:={ { x1 :=3 }, { x2:=1.3 } };
+x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
+x3:={ { x2 :=3.9 },temp5 }; //{ x2:=1.3 }
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayMatching() runs on arrayOper_mycomp{
+ template arrayOper_triplet template1:={{1,2},{2,3},{3,4}};
+ template arrayOper_triplet template2:=
+ {subset(1,2,3),subset(3,4,5),subset(5,6,7,8)};
+ template arrayOper_triplet template3:={superset(1),superset(2),superset(4)};
+ template arrayOper_trecord2 template4:={{1,?,3}};
+ var arrayOper_trecord2 x1:={{1,2,3}};
+ if(match(arrayOper_const13[0],template1)){setverdict(pass);}
+ else {setverdict(fail);}
+ if(not(match(arrayOper_const13[0],template2))){setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(arrayOper_const13[1],template2)){setverdict(pass);}
+ else {setverdict(fail);}
+ if(not(match(arrayOper_const13[1],template3))){setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(arrayOper_const13[2],template3)){setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(x1,template4)){setverdict(pass);}
+ else{setverdict(fail);}
+}
+
+testcase arraySummation() runs on arrayOper_mycomp{
+ var integer x1[2][3]:={{1,2,3},{4,5,6}};
+ var integer i1,i2,sum;
+ x1[1][1]:=3;
+ sum:=0;
+ for(i1:=0;i1<sizeof(x1);i1:=i1+1)
+ {
+ for(i2:=0;i2<sizeof(x1[i1]);i2:=i2+1)
+ {
+ sum:=sum+x1[i1][i2];
+ }
+ }
+ if(sum==19){setverdict(pass);}
+ else{setverdict(fail);}
+}
+
+testcase arrayRotateOperators() runs on arrayOper_mycomp{
+ var integer x1[5]:={1,2,3,4,5}
+ var integer x2[5],x3[5],x4[5],x5[5],x6[5],x7[5];
+ x2 := x1 <@ 1;
+ x3 := x1 <@ 10;
+ x4 := x1 <@ 3 <@ 2;
+ x5 := x1 @> 1;
+ x6 := x1 @> 10;
+ x7 := x1 @> 3 @> 2;
+ if (x2 == {2,3,4,5,1}) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x3 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x4 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x5 == {5,1,2,3,4}) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x6 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x7 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase arrayLengthof() runs on arrayOper_mycomp{
+// lengthof returns the sequential number of the last initialized element of the array
+ var integer x1[2]:={1,2} // last init element is the second
+ var integer x2[2],x3[3],x4[2],x5[5]; // array of basic types
+ x2:={ 1, 2 }; // last init element is the second
+ x3:={1,2, -}; // last init element is the second
+ // x4: last init element is the zero
+ x5[2]:=1; // last init element is the third
+ if (lengthof(x1)==2) {setverdict(pass);} //assignment at declaration
+ else {setverdict(fail);}
+ if (lengthof(x2)==2) {setverdict(pass);} //assignment later
+ else {setverdict(fail);}
+ if (lengthof(x3)==2) {setverdict(pass);} //partly filled, TITAN specific
+ else {setverdict(fail);}
+ if (lengthof(x4)==0) {setverdict(pass);} //empty
+ else {setverdict(fail);}
+ if (lengthof(x5)==3) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+}
+
+testcase arraySizeof() runs on arrayOper_mycomp{
+ var integer x1[2]:={1,2}
+ var integer x2[2],x3[3],x4[2],x5[5]; //array of basic types
+ x2:={ 1, 2 };
+ x3:={1,2, -}; // partly filled array
+ x5[2]:=1; //out of order
+ if (sizeof(x1)==2) {setverdict(pass);} //assignment at declaration
+ else {setverdict(fail);}
+ if (sizeof(x2)==2) {setverdict(pass);} //assignment later
+ else {setverdict(fail);}
+ if (sizeof(x3)==3) {setverdict(pass);} //partly filled, TITAN specific
+ else {setverdict(fail);}
+ if (sizeof(x4)==2) {setverdict(pass);} //empty
+ else {setverdict(fail);}
+ if (sizeof(x5)==5) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+}
+
+testcase arraySizeof2() runs on arrayOper_mycomp{
+ var integer x1[1..3][1]:={{1},{2},{3}};
+ var integer x2[11..12],x3[3..5],x4[-8..-7],x5[-4..0]; //array of basic types
+ x2:={ 1, 2 };
+ x3:={1,2, -}; // partly filled array
+ x5[-3]:=1; //out of order
+ if (sizeof(x1)==3) {setverdict(pass);} //assignment at declaration
+ else {setverdict(fail);}
+ if (sizeof(x1[1])==1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (sizeof(x2)==2) {setverdict(pass);} //assignment later
+ else {setverdict(fail);}
+ if (sizeof(x3)==3) {setverdict(pass);} //partly filled, TITAN specific
+ else {setverdict(fail);}
+ if (sizeof(x4)==2) {setverdict(pass);} //empty
+ else {setverdict(fail);}
+ if (sizeof(x5)==5) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+}
+
+testcase arrayIsvalue() runs on arrayOper_mycomp{
+ var integer x0[2];
+ var integer x1[2] := { 12,34 }
+ var integer x2[2];
+ x2:={ 32, 12 };
+ var integer x3[2 .. 4];
+ var integer x4[2 .. 4] := {32,12,3};
+ var template integer x5[3] := omit;
+ var template integer x6[3] := { 1, 2, 3 } ifpresent;
+
+ if ( isvalue(x0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(x0[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(x1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(x2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(x3) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(x4) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(x5) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(x6) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+testcase emptyTemplateArrayOneDimensional() runs on arrayOper_mycomp{
+ var template charstring csa[10]
+ var template charstring cs
+ //cs := csa[0]
+ if ( isbound(csa[0]) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+testcase emptyTemplateArrayTwoDimensional() runs on arrayOper_mycomp{
+ var template charstring csa[10][10]
+ var template charstring cs
+ //cs := csa[0][1]
+ if ( isbound(csa[0][1]) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+type enumerated DefaultCallHandling {
+ releaseCall, continueCall
+};
+type record DP_AnalysedInfoCriterium {};
+type record of DP_AnalysedInfoCriterium DP_AnalysedInfoCriteriumList;
+template DP_AnalysedInfoCriterium t_MAP_DP_AnalysedInfoCriterium(octetstring ox,
+ integer ix, charstring cx, DefaultCallHandling dx) := {}
+function f_Converter_Charstring_To_Map(in charstring c) return octetstring {
+ return char2oct(c);
+}
+template DP_AnalysedInfoCriterium t_MAP_D_CSI(template DP_AnalysedInfoCriteriumList tdpl, integer num) := { }
+
+testcase TemplateArray() runs on arrayOper_mycomp{
+
+ var template DP_AnalysedInfoCriterium v_DP_AnalysedInfoCriterium[8];
+ var charstring v_gsmSCF := "howdy";
+ var template DP_AnalysedInfoCriterium v_D_CSI_1 ;
+ v_DP_AnalysedInfoCriterium[0] := t_MAP_DP_AnalysedInfoCriterium( '91'O& f_Converter_Charstring_To_Map( "491799000000003"), // ISDN-AddressString,
+ 50000, // ServiceKey,
+ v_gsmSCF,// ISDN-AddressString,
+ releaseCall); // DefaultCallHandling,
+ v_DP_AnalysedInfoCriterium[1] := t_MAP_DP_AnalysedInfoCriterium( '91'O& f_Converter_Charstring_To_Map( "491799000000002"), // ISDN-AddressString,
+ 32768, // ServiceKey,
+ v_gsmSCF,// ISDN-AddressString,
+ releaseCall); // DefaultCallHandling,
+
+ v_DP_AnalysedInfoCriterium[2] := t_MAP_DP_AnalysedInfoCriterium( 'A1'O&f_Converter_Charstring_To_Map( "491799000000001"), // ISDN-AddressString,
+ 128, // ServiceKey,
+ v_gsmSCF,// ISDN-AddressString,
+ continueCall); // DefaultCallHandling,
+
+ v_D_CSI_1 := t_MAP_D_CSI ({v_DP_AnalysedInfoCriterium[0], v_DP_AnalysedInfoCriterium[1], v_DP_AnalysedInfoCriterium[2 ]},//DP-AnalysedInfoCriteriaList
+ 3); //CamelCapabilityHandling
+
+ if ( isbound(t_MAP_D_CSI({v_DP_AnalysedInfoCriterium[0], v_DP_AnalysedInfoCriterium[1], v_DP_AnalysedInfoCriterium[2 ]},3)) )
+ { setverdict(pass); } else { setverdict(fail); };
+}
+
+control
+{
+ const arrayOper_tsetof2 cl_1[3][3]:={ // constant in control part
+ {{1,2},{2,3},{3,4}},{{1,2},{4,5},{6,7}},{{2,1},{3,2},{4,3}}};
+ var arrayOper_tsetof2 vl_1[3][3]; //variable in control part
+
+ execute(arrayAssign());
+ execute(arrayAssignEnum());
+ execute(arrayAssignRec());
+ execute(arrayAssignRecof());
+ execute(arrayAssignSet());
+ execute(arrayAssignSetof());
+ execute(arrayAssignUnion());
+ execute(arrayAssignArray());
+ execute(arrayAssignSubArray());
+ execute(arrayAssignRangedArray());
+ execute(arrayAssignElem());
+ execute(arrayAssignElemEnum());
+ execute(arrayAssignElemRec());
+ execute(arrayAssignElemRecof());
+ execute(arrayAssignElemSet());
+ execute(arrayAssignElemSetof());
+ execute(arrayAssignElemUnion());
+ execute(arrayAssignSubArrayElem());
+ execute(arrayAssignRangedArrayElem());
+ execute(arrayConst());
+ execute(arrayConstEnum());
+ execute(arrayConstRec());
+ execute(arrayConstRecof());
+ execute(arrayConstSet());
+ execute(arrayConstSetof());
+ execute(arrayConstUnion());
+ execute(arrayComp());
+ execute(arrayCompConst());
+ execute(arrayCompEnum());
+ execute(arrayCompRec());
+ execute(arrayCompRecof());
+ execute(arrayCompSet());
+ execute(arrayCompSetof());
+ execute(arrayCompUnion());
+ execute(arrayMatching());
+ execute(arraySummation());
+
+ execute(arrayRotateOperators());
+ execute(arrayLengthof());
+ execute(arraySizeof());
+ execute(arraySizeof2());
+ execute(arrayIsvalue());
+
+ execute(emptyTemplateArrayOneDimensional());
+ execute(emptyTemplateArrayTwoDimensional());
+ execute(TemplateArray());
+}
+
+}
diff --git a/Regression_Test_java/src/TassignmentNotation.asn b/Regression_Test_java/src/TassignmentNotation.asn
new file mode 100644
index 0000000000000000000000000000000000000000..bdf695fd358909eb2a238ed8a2411f233475868e
--- /dev/null
+++ b/Regression_Test_java/src/TassignmentNotation.asn
@@ -0,0 +1,24 @@
+--/////////////////////////////////////////////////////////////////////////////
+-- 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
+--
+--/////////////////////////////////////////////////////////////////////////////
+ASN-Definitions DEFINITIONS AUTOMATIC TAGS ::=
+BEGIN
+IMPORTS ; -- nothing
+
+ASN-CSTR ::= CHARACTER STRING
+ASN-SEQ-I ::= SEQUENCE (SIZE (1..10)) OF INTEGER
+ASN-SEQ-R ::= SEQUENCE { asn-seq-i ASN-SEQ-I }
+
+idx-ASN INTEGER ::= 0
+
+END
diff --git a/Regression_Test_java/src/TassignmentNotation.ttcn b/Regression_Test_java/src/TassignmentNotation.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..1b4c3d01fd0022a090e9e5f478d60608ccb0c511
--- /dev/null
+++ b/Regression_Test_java/src/TassignmentNotation.ttcn
@@ -0,0 +1,343 @@
+/******************************************************************************
+ * 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
+ * Szabados, Kristof
+ *
+ ******************************************************************************/
+module TassignmentNotation
+{
+import from ASN_Definitions language "ASN.1 : 1997" all
+type component empty { }
+type record tri
+{
+ integer a,
+ integer b,
+ integer c
+}
+function f1 () return integer { return 100 }
+type record of tri tritri
+type record of tritri tritritri
+//modulepar tritri tsp_param :=
+//{
+// { 0, 1, 2 },
+// { 4, 5, 6 }
+//}
+//modulepar tritritri tsp_param_param :=
+//{
+// { { 10, 11, 12 }, { 13, 14, 15 } },
+// { { 16, 17, 18 }, { 19, 20, 21 } }
+//}
+//modulepar integer tsp_index := 0
+//modulepar charstring tsp_editor := "mcedit"
+testcase asns () runs on empty
+{
+ template ASN_SEQ_R asn_temp := { asn_seq_i := { 0, 1, 2 } }
+ template ASN_SEQ_R asn_temp_mod modifies asn_temp := { asn_seq_i := { [1] := 0, [2] := 0 } }
+ var ASN_SEQ_R asn_temp_exp := { asn_seq_i := { 0, 0, 0 } }
+ if (match (asn_temp_exp, asn_temp_mod)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ var integer index := 1
+ var ASN_SEQ_I v1 := { 1, 2, 3 }
+ var ASN_SEQ_I v2 := { [0] := 100, [index] := 200, [index + 1] := 300 }
+ var ASN_SEQ_I v1_exp := { 100, 200, 300 }
+ v1[0] := 100 * v1[0]
+ v1[index] := 100 * v1[index + 1 - 1]
+ v1[index + 1] := v2[2]
+ if (v1 != v2) { setverdict (fail, __LINE__) }
+ else { setverdict (pass) }
+ v1 := { 100 }
+ /* Evaluated from left to right. */
+ v1 := { [sizeof (v1)] := 200, [sizeof (v1)] := 300 }
+ if (v1 != v1_exp) { setverdict (fail, __LINE__) }
+ else { setverdict (pass) }
+ var ASN_SEQ_R v3 := { asn_seq_i := { 1, 2, 3 } }
+ var ASN_SEQ_R v4 := { asn_seq_i := { [index] := 111 } }
+ var ASN_SEQ_R v3_exp := { asn_seq_i := { 11, 22, 33 } }
+ var ASN_SEQ_R v5 := { asn_seq_i := { [1000 + index + sizeof (v3.asn_seq_i)] := 1000 } }
+ v4.asn_seq_i[index] := 22
+ v4 := { asn_seq_i := { [index - 1] := index + 10, [2] := 33 } }
+ v3 := v4
+ v3 := { asn_seq_i := { [index - 1] := 11 } }
+ if (v3 != v3_exp) { setverdict (fail, __LINE__) }
+ else { setverdict (pass) }
+ v4.asn_seq_i[0] := v3.asn_seq_i[0]
+ if (v4 != v3_exp) { setverdict (fail, __LINE__) }
+ else { setverdict (pass) }
+ if (isvalue (v4)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (v4.asn_seq_i[index])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (v2[valueof (asn_temp_mod.asn_seq_i[0])])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (sizeof (v5.asn_seq_i) == 1005) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (asn_temp_mod)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ /* Template with uninitialized elements. */
+ template ASN_SEQ_R mod2 modifies asn_temp_mod := { asn_seq_i := { [100] := 0, [200] := 0 } }
+ if (not isvalue (mod2)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (not isvalue (mod2.asn_seq_i)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+}
+type record array_element { integer a, integer b }
+type array_element array_elements[4]
+type record of array_element array_record_of
+type record of integer intlist
+type set of integer intset
+testcase arrays () runs on empty
+{
+ var integer first := 0
+ var integer second := 1
+ var integer third := 2
+ var array_element arr2[4]
+ var array_element arr3[14]
+ var array_elements array :=
+ {
+ [first] := { first, 0 },
+ [second] := { 1, second },
+ [third] := { third, 2 },
+ [third + 1] := { 3, third + 1 }
+ }
+ arr2 := array
+ arr2 := { [3] := { 100, third } }
+ arr3 := { [10] := arr2[1] }
+ var array_elements array_expected := { { 0, 0 }, { 1, 1 }, { 2, 2 }, { 3, third + 1 } }
+ if (array == array_expected) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ template array_elements array_base := { { 100, 200 }, { -1, -2 }, { 1000, 2000 }, { -10, -20 } }
+ template array_elements array_modified modifies array_base :=
+ {
+ [0] := { 0, 0 },
+ [2] := { third, third },
+ [second] := { 1, first + 1 },
+ [third + 1] := { third + 1, 3 }
+ }
+ if (match (array_expected, array_modified)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ /* "array[500 + f1 ()]" is a dynamic test case error. */
+ if (isvalue (array[500 + f1 () - 599])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (array)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (array[f1 () - f1 () + 1].a)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (arr2[500 + f1 () - 598])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (arr2)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (not isvalue (arr3)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (arr2[f1 () - f1 () + 1].a)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (sizeof (arr3) == 14) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ /* Creating holes in arrays is not possible. (Without dynamic test case
+ error.) */
+}
+//testcase configs () runs on empty
+//{
+// template tritri tsp_param_expected :=
+// {
+// { 0, 1, 2 },
+// { 3, 4, 5 },
+// { 33, 22, 11 },
+// { 100, 100, 100 }
+// }
+// var tritri tsp_param_exp2 :=
+// {
+// [0] := { 0, 1, 2 },
+// [1] := { 3, 4, 5 },
+// [2] := { 33, 22, 11 },
+// [3] := { 100, 100, 100 }
+// }
+// var tritri tsp_param_exp3 :=
+// {
+// [0] := { 0, 1, 2 },
+// [3] := { 3, 4, 5 },
+// [2] := { 33, 22, 11 },
+// [1] := { 100, 100, 100 }
+// }
+// if (match (tsp_param, tsp_param_expected)) { setverdict (pass) }
+// else { setverdict (fail, __LINE__) }
+// if (tsp_param == tsp_param_exp2) { setverdict (pass) }
+// else { setverdict (fail, __LINE__) }
+// if (tsp_param != tsp_param_exp3) { setverdict (pass) }
+// else { setverdict (fail, __LINE__) }
+//}
+type record of my mylist
+type set of my_set myset
+type record my { intlist ilist, integer i }
+type record my_set { intset iset, integer i }
+type record dummy { mylist mlist }
+type record dummy_set { myset mset }
+testcase recofs () runs on empty
+{
+ template dummy t1 := { mlist := { { ilist := { 0 }, i := 0 } } }
+ template dummy t1_mod1 modifies t1 := { mlist := { [0] := { ilist := { 1 } } } }
+ var dummy t1_mod_exp := { mlist := { { ilist := { 1 }, i := 0 } } }
+ if (match (t1_mod_exp, t1_mod1)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ var integer index := 0
+ /* An index like "index + 1 - 1" caused circular reference with previous
+ versions. The name was not set correctly. */
+ template dummy t1_mod2 modifies t1 := { mlist := { [index + 1 - index - 1] := { ilist := { [0 - index] := index + 1 } } } }
+ if (match (t1_mod_exp, t1_mod2)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ var intlist v1 := { [0] := 0, [index + 1] := 1 }
+ var intlist v1_exp := { 100, 1 }
+ var intlist v3 := { [100 + f1 ()] := 100 }
+ v1[1] := index + 1
+ v1 := { [0] := 100 }
+ if (v1 == v1_exp) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ var dummy v2 := { mlist := { { ilist := { 1, 2 }, i := 500 } } }
+ v2 := { mlist := { { ilist := { [index + 2] := 3 }, i := v2.mlist[index].i - 100 } } }
+ var dummy v2_exp := { mlist := { { ilist := { -, -, 3 }, i := 400 } } }
+ if (v2 == v2_exp) { setverdict (pass) }
+ else { setverdict (fail, __LINE__, ": ", match(v2, v2_exp)) }
+ if (not isvalue (t1_mod2.mlist[500])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (t1_mod2.mlist[0])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (not isvalue (t1_mod2.mlist[1])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (not isvalue (v2)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (not isvalue (v2.mlist[index].ilist[1])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (v1)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (v1[0])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (not isvalue (v3)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (v3[200])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (sizeof (v3) == 201) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+}
+testcase setofs () runs on empty
+{ /* Same as the previous. */
+ template dummy_set t1 := { mset := { { iset := { 0 }, i := 0 } } }
+ template dummy_set t1_mod1 modifies t1 := { mset := { [0] := { iset := { 1 } } } }
+ var dummy_set t1_mod_exp := { mset := { { iset := { 1 }, i := 0 } } }
+ if (match (t1_mod_exp, t1_mod1)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ var integer index := 0
+ template dummy_set t1_mod2 modifies t1 := { mset := { [index + 1 - index - 1] := { iset := { [0 - index] := index + 1 } } } }
+ if (match (t1_mod_exp, t1_mod2)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ var intset v1 := { [0] := 0, [index + 1] := 1 }
+ var intset v1_exp := { 100, 1 }
+ v1[1] := index + 1
+ v1 := { [0] := 100 }
+ if (v1 == v1_exp) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ var dummy_set v2 := { mset := { { iset := { 1, 2 }, i := 500 } } }
+ var dummy_set v2_exp := { mset := { { iset := { -, -, 3 }, i := 400 } } }
+ var intset v3 := { [100 + f1 ()] := 100 }
+ v2 := { mset := { { iset := { [index + 2] := 3 }, i := v2.mset[index].i - 100 } } }
+ if (v2 == v2_exp) { setverdict (pass) }
+ else { setverdict (fail, __LINE__, ": ", match(v2, v2_exp)) }
+ /* It should be a compile only test. */
+ var ASN_CSTR asnstr
+ asnstr := { { fixed := NULL }, "{ itu-t identified-organization etsi(0) reserved(127) etsi-identified-organization(0) ericsson(5) }", 'abcd'O };
+ var objid oi := objid { itu_t (0) 1 2 }
+ /* Using isvalue. */
+ if (isvalue (t1_mod2)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (t1_mod2.mset)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ /* Indexing with constants was a problem with INDEXED_TEMPLATE_LIST
+ nodes. */
+ if (not isvalue (t1_mod2.mset[500])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (t1_mod2.mset[0])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (not isvalue (t1_mod2.mset[1])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (not isvalue (v2)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (not isvalue (v2.mset[index].iset[1])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (v1)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (v1[0])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (not isvalue (v3)) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (isvalue (v3[200])) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+ if (sizeof (v3) == 201) { setverdict (pass) }
+ else { setverdict (fail, __LINE__) }
+}
+
+type integer intarr[2..5]
+
+testcase tc_TR938_939() runs on empty {
+ // Constants with the same base-types, but initialized in different ways.
+ // All the same. Evaluated during CP. It's specific to the mentioned
+ // TR939, but the restructuring for TR938 should make this obsolete.
+ const intlist il1 := { [0] := 0, [1] := 1 }
+ const intlist il2 := { [0] := 0, [1] := 1 }
+ const intlist il3 := { [1] := 1, [0] := 0 }
+ const intlist il4 := { 0, 1 }
+ const intlist il5 := { 1, 0 }
+ const intlist il6 := { 0, 1, 2 }
+ const intlist il7 := { [0] := 0, [1] := 1, [2] := 2 }
+ const intlist il8 := { [2] := 2, [1] := 1, [0] := 0 }
+ if (il1 == il1) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ if (il1 == il2) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ if (il1 == il3) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ if (il1 == il4) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ if (il1 == il2 and il2 == il3
+ and il3 == il4) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ if (il1 != il5) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ if (il1 != il6) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ if (il1 != il7) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ if (il1 != il8) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ // Initializing value-range arrays.
+ var intarr ia1 := { [2] := 2, [3] := 3, [4] := 4, [5] := 5 }
+ var intarr ia2 := { 2, 3, 4, 5 }
+ if (ia1 == ia2) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ // Initializing arrays using dynamic index values.
+ var integer i := 2
+ var intarr ia3 := { [i] := 2, [i] := 2 }
+ ia3[i + 1] := 3; ia3[i + 2] := 4; ia3[i + 3] := 5
+ var intarr ia4 := { [i] := 2, [i] := 2 }
+ ia4[i + 1] := 3; ia4[i + 2] := 4; ia4[i + 3] := 5
+ if (ia3 == ia4) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+}
+
+// Test for TR943. The code section was not set correctly for references from
+// different modules. The module of the referenced index should come after
+// this module. Otherwise, the test is useless.
+template intlist t_intlist := { 0 }
+template intlist tm_intlist modifies t_intlist := { [idx_ASN] := 1 }
+testcase tc_TR943() runs on empty {
+ // Same for values.
+ var intlist il1 := { [idx_ASN] := 1 }
+ if (il1 == { 1 }) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ if (match(il1, tm_intlist)) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+}
+
+control
+{
+ execute (asns ())
+ execute (recofs ())
+ execute (setofs ())
+ execute (arrays ())
+// execute (configs ())
+ execute (tc_TR938_939 ())
+ execute (tc_TR943 ())
+}
+}
diff --git a/Regression_Test_java/src/TbasicStatem.ttcn b/Regression_Test_java/src/TbasicStatem.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..0e3fcff615299ca27b684d66252d992c60ac869f
--- /dev/null
+++ b/Regression_Test_java/src/TbasicStatem.ttcn
@@ -0,0 +1,386 @@
+/******************************************************************************
+ * 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
+ * Gecse, Roland
+ * Harai, Tibor
+ * Kovacs, Ferenc
+ * Raduly, Csaba
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TbasicStatem {
+type component basicStatem_mycomp {};
+
+
+testcase basicStatemIf() runs on basicStatem_mycomp {
+// literal constants in the expression
+if (true) {setverdict(pass)}
+ else {setverdict(fail)}
+if (false) {setverdict(fail)}
+ else {setverdict(pass)}
+// variable references in the expression
+var boolean b := true;
+if (b) {setverdict(pass)}
+ else {setverdict(fail)}
+b := false;
+if (b) {setverdict(fail)}
+ else {setverdict(pass)}
+}
+
+testcase basicStatemElseIf() runs on basicStatem_mycomp {
+// literal constants in the expressions
+if (false) {setverdict(fail)}
+ else if (false) {setverdict(fail)}
+ else {setverdict(pass)}
+if (false) {setverdict(fail)}
+ else if (true) {setverdict(pass)}
+ else {setverdict(fail)}
+if (true) {setverdict(pass)}
+ else if (false) {setverdict(fail)}
+ else {setverdict(fail)}
+// variable references in the expressions
+var boolean b1 := false, b2 := false;
+if (b1) {setverdict(fail)}
+ else if (b2) {setverdict(fail)}
+ else {setverdict(pass)}
+b2 := true;
+if (b1) {setverdict(fail)}
+ else if (b2) {setverdict(pass)}
+ else {setverdict(fail)}
+b1 := true;
+if (b1) {setverdict(pass)}
+ else if (b2) {setverdict(fail)}
+ else {setverdict(fail)}
+}
+
+type record address { integer filed }
+
+testcase basicStatemSelectCase() runs on basicStatem_mycomp {
+var bitstring bit1, bit2;
+bit1:='1001'B;
+bit2:='11001'B;
+select (bit1) {
+ case ('11'B,'101000101'B) { setverdict(fail); }
+ case ('1001'B,bit2,'10'B) { setverdict(pass); }
+ case else { setverdict(inconc); }
+}
+var boolean boo1, boo2;
+boo1:=false;
+boo2:=true;
+select (boo1) {
+ case (true,boo2) { setverdict(fail); }
+ case (false) { setverdict(pass); }
+ case else { setverdict(inconc); }
+}
+var charstring char1, char2;
+char1:="A";
+char2:="cvs";
+select (char1) {
+ case ("lkjsd",char2) { setverdict(fail); }
+ case ("ff","C","A") { setverdict(pass); }
+ case else { setverdict(inconc); }
+}
+var universal charstring uchar1, uchar2;
+uchar1:=char(0,0,1,113);
+uchar2:=char(0,0,0,129);
+select (uchar1) {
+ case (uchar2,char(0,0,0,67)) { setverdict(fail); }
+ case (char(0,0,0,69),char(0,0,0,68),char(0,0,1,113)) { setverdict(pass); }
+ case else { setverdict(inconc); }
+}
+var integer int1, int2;
+int1:= 4;
+int2:= 7;
+select (int1) {
+ case (3,0) { setverdict(fail); }
+ case (11,int2,4) { setverdict(pass); }
+ case else { setverdict(inconc); }
+}
+select (int1 + int2) {
+ case (3,0) { setverdict(fail); }
+ case (11,4) { setverdict(pass); }
+ case else { setverdict(inconc); }
+}
+select (int1 + int2) {
+ case (3,0) { setverdict(fail); }
+ case (3) { setverdict(fail); }
+ case (0,3) { setverdict(fail); }
+ case (0,4) { setverdict(fail); }
+ case (99999999999999999999999999999999999) { setverdict(fail); }
+ case (11,4) { setverdict(pass); }
+ case else { setverdict(inconc); }
+ case else { setverdict(inconc); }
+}
+select (int1 + int2) {
+ case (3,0) { setverdict(fail); }
+ case (3) { setverdict(fail); }
+ case (0,3) { setverdict(fail); }
+ case (0,4) { setverdict(fail); }
+ case (11,4) { setverdict(pass); }
+ case else { setverdict(inconc); }
+}
+var octetstring octet1, octet2;
+octet1:= 'A9'O;
+octet2:= '1267FD'O;
+select (octet1) {
+ case ('FF'O,'A9'O,octet2) { setverdict(pass); }
+ case ('067B'O,'FA'O) { setverdict(fail); }
+ case else { setverdict(inconc); }
+}
+var hexstring hex1, hex2;
+hex1:= '12C'H;
+hex2:= 'A778F'H;
+select (hex1) {
+ case ('D'H,'AA'H) { setverdict(fail); }
+ case (hex2,'12C'H,'3'H) { setverdict(pass); }
+ case else { setverdict(inconc); }
+}
+var verdicttype verd1, verd2;
+verd1:= none;
+verd2:= error;
+select (verd1) {
+ case (pass,fail) { setverdict(fail); }
+ case (verd2,none,inconc) { setverdict(pass); }
+ case else { setverdict(inconc); }
+}
+var float float1, float2;
+float1:= 2.3;
+float2:= 7.89;
+select (float1) {
+ case (float2,0.4) { setverdict(fail); }
+ case (2.31,7.0,2.29) { setverdict(inconc); }
+ case else { setverdict(pass); }
+}
+var address v_add1 := {23};
+var address v_add2 := {47};
+select (v_add1) {
+ case ({56},v_add2) { setverdict(fail); }
+ case ({4},{23},{234}) { setverdict(pass); }
+ case else { setverdict(inconc); }
+}
+}
+
+testcase basicStatemFor() runs on basicStatem_mycomp {
+var integer i,x1,x2;
+x1:=0;
+x2:=0;
+for (i:=1;i<=10;i:=i+1) {x1:=x1+1};
+for (var integer j:=1;j<1000;j:=j*2) {x2:=x2+2;}
+if (x1==10) {setverdict(pass);} // index variable declared separately
+ else {setverdict(fail);}
+if (x2==20) {setverdict(pass);} // index variable declared in the loop
+ else {setverdict(fail);}
+}
+
+testcase basicStatemWhile() runs on basicStatem_mycomp {
+var integer i,x1,x2;
+x1:=0;
+x2:=0;
+i:=1;
+while (i<=10) {i:=i+1; x1:=x1+1};
+i:=1
+while (i<=0) {i:=i+1; x2:=x2+1};
+if (x1==10) {setverdict(pass)}
+ else {setverdict(fail)};
+if (x2==0) {setverdict(pass)} // zero-sized loop
+ else {setverdict(fail)};
+
+}
+
+testcase basicStatemDoWhile() runs on basicStatem_mycomp {
+var integer i,x1,x2;
+x1:=0;
+x2:=0;
+i:=1;
+do {i:=i+1; x1:=x1+1} while (i<=10);
+i:=1;
+do {i:=i+1; x2:=x2+1} while (i<=0);
+if (x1==10) {setverdict(pass)}
+ else {setverdict(fail)};
+if (x2==1) {setverdict(pass)} // "zero-sized" loop
+ else {setverdict(fail)};
+}
+
+//testcase basicStatemLabelGoto1() runs on basicStatem_mycomp {
+//goto L1; // forward
+//setverdict(fail);
+//label L1;
+//setverdict(pass);
+//}
+//
+//testcase basicStatemLabelGoto2() runs on basicStatem_mycomp {
+//var integer x;
+//x:=0
+//label L1; // backward
+//x:=x+1;
+//if (x==2) {setverdict(pass)}
+//else { goto L1};
+//}
+
+//testcase basicStatemStop() runs on basicStatem_mycomp {
+//setverdict(pass);
+//stop;
+//setverdict(fail);
+//}
+
+function f_aliasValue(integer par1, in integer par2, out integer par3,
+ inout integer par4, template integer par5)
+{
+ // all parameters should be zero, par3 is inaccessible yet
+ if (par1 == 0 and par2 == 0 and par4 == 0 and valueof(par5) == 0)
+ { setverdict(pass); }
+ else { setverdict(fail); }
+ par3 := 1;
+ // par3 and par4 should change to one, the rest should remain zero
+ if (par1 == 0 and par2 == 0 and par3 == 1 and par4 == 1 and
+ valueof(par5) == 0) { setverdict(pass); }
+ else { setverdict(fail); }
+ par1 := 2;
+ // nothing except par1 should change
+ if (par1 == 2 and par2 == 0 and par3 == 1 and par4 == 1 and
+ valueof(par5) == 0) { setverdict(pass); }
+ else { setverdict(fail); }
+}
+
+function f_aliasTemplate(template integer par1, in template integer par2,
+ out template integer par3, inout template integer par4, integer par5)
+{
+ if (valueof(par1) == 0 and valueof(par2) == 0 and valueof(par4) == 0 and
+ par5 == 0) { setverdict(pass); }
+ else { setverdict(fail); }
+ par3 := 1;
+ if (valueof(par1) == 0 and valueof(par2) == 0 and valueof(par3) == 1 and
+ valueof(par4) == 1 and par5 == 0) { setverdict(pass); }
+ else { setverdict(fail); }
+ par1 := 2;
+ if (valueof(par1) == 2 and valueof(par2) == 0 and valueof(par3) == 1 and
+ valueof(par4) == 1 and par5 == 0) { setverdict(pass); }
+ else { setverdict(fail); }
+}
+
+testcase basicStatemfunctionCallAlias() runs on basicStatem_mycomp
+{
+ var integer i := 0;
+ f_aliasValue(i, i, i, i, i);
+ if (i == 1) { setverdict(pass); }
+ else { setverdict(fail); }
+ var template integer j := 0;
+ f_aliasTemplate(j, j, j, j, valueof(j));
+ if (valueof(j) == 1) { setverdict(pass); }
+ else { setverdict(fail); }
+}
+
+type record r_empty { }
+type set s_empty { }
+type record of r_empty ro_empty
+type set of s_empty so_empty
+type union u_empty { ro_empty f1, so_empty f2 }
+type anytype a_empty
+type enumerated e_empty { f1, f2 }
+type component c_HM79493
+{
+ var integer i; var template integer it
+ var float f; var template float ft
+ var boolean b; var template boolean bt
+ var verdicttype v; var template verdicttype vt
+ var bitstring bs; var template bitstring bst
+ var hexstring hs; var template hexstring hst
+ var octetstring os; var template octetstring ost
+ var charstring cs; var template charstring cst
+ var universal charstring ucs; var template universal charstring ucst
+ var c_HM79493 c; var template c_HM79493 ct
+ var r_empty r; var template r_empty rt
+ var s_empty s; var template s_empty st
+ var ro_empty ro; var template ro_empty rot
+ var so_empty so; var template so_empty sot
+ var u_empty u; var template u_empty ut
+ var a_empty a; var template a_empty at
+ var e_empty e; var template e_empty et
+
+ // HQ19911: uncomment and watch the DTE
+ // var template ro_empty tro := { permutation({}) }
+}
+
+testcase tc_HM79493_set() runs on c_HM79493
+{
+ i := 100; it := 100
+ f := 100.0; ft := 100.0
+ b := true; bt := true
+ v := pass; vt := pass
+ bs := '00'B; bst := '00'B
+ hs := '00'H; hst := '00'H
+ os := '00'O; ost := '00'O
+ cs := "00"; cst := "00"
+ ucs := char(0, 0, 0, 0); ucst := char(0, 0, 0, 0)
+ c := self; ct := self
+ r := { }; rt := { }
+ s := { }; st := { }
+ ro := { }; rot := { }
+ so := { }; sot := { }
+ u := { f1 := { } }; ut := { f1 := { } }
+ a := { u_empty := { f1 := { } } }; at := { u_empty := { f1 := { } } }
+ e := f1; et := f1
+ setverdict(pass)
+}
+
+testcase tc_HM79493_check() runs on c_HM79493
+{
+ if (log2str(i) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(it) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(f) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(ft) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(b) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(bt) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(v) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(vt) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(bs) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(bst) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(hs) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(hst) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(os) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(ost) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(cs) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(cst) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(ucs) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(ucst) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(c) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(ct) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(r) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(rt) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(s) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(st) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(ro) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(rot) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(so) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(sot) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(u) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(ut) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(a) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(at) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(e) == "<unbound>") { setverdict(pass) } else { setverdict(fail) }
+ if (log2str(et) == "<uninitialized template>") { setverdict(pass) } else { setverdict(fail) }
+}
+
+control {
+ execute(basicStatemIf());
+ execute(basicStatemElseIf());
+ execute(basicStatemSelectCase());
+ execute(basicStatemFor());
+ execute(basicStatemWhile());
+ execute(basicStatemDoWhile());
+// execute(basicStatemLabelGoto1());
+// execute(basicStatemLabelGoto2());
+// execute(basicStatemStop());
+ //execute(basicStatemfunctionCallAlias());
+ execute(tc_HM79493_set()); // Set component variables/variable templates.
+ execute(tc_HM79493_check()); // All component variables/variable templates must be unbound.
+}
+} with { extension "anytype u_empty" }
+
diff --git a/Regression_Test_java/src/TbitstrOper.ttcn b/Regression_Test_java/src/TbitstrOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..4cbd428cb04facc624bcd19236c5c7e3c03bef1d
--- /dev/null
+++ b/Regression_Test_java/src/TbitstrOper.ttcn
@@ -0,0 +1,709 @@
+/******************************************************************************
+ * 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
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TbitstrOper
+{ type component bitstrOper_comptype { };
+const bitstring TbitstrOper_const1qw:='11111111000000001111'B;//FIXME for bughunt only
+const bitstring TbitstrOper_const1:='1000'B;
+
+testcase bitstrAssign() runs on bitstrOper_comptype
+{ var bitstring x1:='01101'B;
+ var bitstring x2,x3,x4;
+ x2:='0111'B;
+ x4:='01'B;
+ x3:=''B;
+ x4:='0101'B;
+ if (x1=='01101'B) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+ if (x2=='0111'B) {setverdict(pass);} //later
+ else {setverdict(fail);}
+ if (x3==''B) {setverdict(pass);} //empty string
+ else {setverdict(fail);}
+ if (x4=='0101'B) {setverdict(pass);} //change of size
+ else {setverdict(fail);}
+}
+
+testcase bitstrAssignElem10() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3,x4,x5,x6;
+ x1:='11111'B;
+ x4:='11111'B;
+ x2:='00000'B;
+ x5:='11111'B;
+ x3:='1'B;
+ x6:='0'B
+ x3:=x2[1];
+ x1[1]:='0'B;
+ x4[3]:=x2[3];
+ x5[1]:=x6;
+ if (x1[0]=='1'B) {setverdict(pass);} //accessing an element
+ else {setverdict(fail);}
+ if (x3=='0'B) {setverdict(pass);} //change string to element
+ else {setverdict(fail);}
+ if (x1=='10111'B) {setverdict(pass);} //change element to value
+ else {setverdict(fail);}
+ if (x4=='11101'B) {setverdict(pass);} //change element to element
+ else {setverdict(fail);}
+ if (x5=='10111'B) {setverdict(pass);} //change element to string
+ else {setverdict(fail);}
+}
+
+testcase bitstrAssignElem01() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3,x4,x5,x6;
+ x1:='00000'B;
+ x2:='11111'B;
+ x4:='00000'B;
+ x5:='00000'B;
+ x6:='1'B;
+ x3:='0'B;
+ x3:=x2[1];
+ x1[2]:='1'B;
+ x4[1]:=x2[4];
+ x5[1]:=x6;
+ if (x3=='1'B) {setverdict(pass);} //change string to element
+ else {setverdict(fail);}
+ if (x1=='00100'B) {setverdict(pass);} //change element to value
+ else {setverdict(fail);}
+ if (x4=='01000'B) {setverdict(pass);} //change element to element
+ else {setverdict(fail);}
+ if (x5=='01000'B) {setverdict(pass);} //change element to string
+ else {setverdict(fail);}
+}
+
+testcase bitstrAssignElem00() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3,x4,x5,x6;
+ x1:='00000'B;
+ x2:='00000'B;
+ x4:='00000'B;
+ x5:='00000'B;
+ x6:='0'B;
+ x3:='0'B;
+ x3:=x2[1];
+ x1[2]:='0'B;
+ x4[1]:=x2[4];
+ x5[1]:=x6;
+ if (x3=='0'B) {setverdict(pass);} //change string to element
+ else {setverdict(fail);}
+ if (x1=='00000'B) {setverdict(pass);} //change element to value
+ else {setverdict(fail);}
+ if (x4=='00000'B) {setverdict(pass);} //change element to element
+ else {setverdict(fail);}
+ if (x5=='00000'B) {setverdict(pass);} //change element to string
+ else {setverdict(fail);}
+}
+
+testcase bitstrAssignElem11() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3,x4,x5,x6;
+ x1:='11111'B;
+ x2:='11111'B;
+ x4:='11111'B;
+ x5:='11111'B;
+ x6:='1'B;
+ x3:='1'B;
+ x3:=x2[1];
+ x1[2]:='1'B;
+ x4[1]:=x2[4];
+ x5[1]:=x6;
+ if (x3=='1'B) {setverdict(pass);} //change string to element
+ else {setverdict(fail);}
+ if (x1=='11111'B) {setverdict(pass);} //change element to value
+ else {setverdict(fail);}
+ if (x4=='11111'B) {setverdict(pass);} //change element to element
+ else {setverdict(fail);}
+ if (x5=='11111'B) {setverdict(pass);} //change element to string
+ else {setverdict(fail);}
+}
+
+testcase bitstrAssignElemAdd() runs on bitstrOper_comptype
+{var bitstring x1,x2;
+ x1:='000'B;
+ x2:='1111'B;
+ x1[3]:='1'B;
+ x2[4]:=x1[0];
+ if (x1=='0001'B) {setverdict(pass);} //add "1"
+ else {setverdict(fail);}
+ if (x2=='11110'B) {setverdict(pass);} //add "0"
+ else {setverdict(fail);}
+}
+
+testcase bitstrLengthof() runs on bitstrOper_comptype
+{ var bitstring x1:='01101'B;
+ var bitstring x2,x3,x4,x5;
+ x2:='0111'B;
+ x4:='01'B;
+ x5:='01'B;
+ x3:=''B;
+ x4:='0101'B;
+ x5[2]:='0'B;
+ if (lengthof(x1)==5) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+ if (lengthof(x2)==4) {setverdict(pass);} //later
+ else {setverdict(fail);}
+ if (lengthof(x3)==0) {setverdict(pass);} //empty string
+ else {setverdict(fail);}
+ if (lengthof(x4)==4) {setverdict(pass);} //change of size
+ else {setverdict(fail);}
+ if (lengthof(x5)==3) {setverdict(pass);} //add element
+ else {setverdict(fail);}
+}
+
+testcase bitstrConst() runs on bitstrOper_comptype
+{const bitstring TbitstrOper_const3:='0001'B;
+ if (TbitstrOper_const1=='1000'B) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+ if (TbitstrOper_const3=='0001'B) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+}
+
+testcase bitstrComp_str_str() runs on bitstrOper_comptype
+{var bitstring x1,x2,x3;
+ x1:='0110'B;
+ x2:='0110'B;
+ x3:='011'B;
+ if (x1==x2) {setverdict(pass);} //equality, equals
+ else {setverdict(fail);}
+ if (not(x3==x2)) {setverdict(pass);} //equality, not equals
+ else {setverdict(fail);}
+ if (x1!=x3) {setverdict(pass);} //non-equality, not equals
+ else {setverdict(fail);}
+ if (not(x1!=x2)) {setverdict(pass);} //non-equality, equals
+ else {setverdict(fail);}
+}
+
+testcase bitstrComp_el_str() runs on bitstrOper_comptype
+{var bitstring x1,x2,x3;
+ x1:='0110'B;
+ x2:='1'B;
+ x3:='0'B;
+ if (x1[2]==x2) {setverdict(pass);} //equality, equals
+ else {setverdict(fail);}
+ if (not(x1[2]==x3)) {setverdict(pass);} //equality, not equals
+ else {setverdict(fail);}
+ if (x1[1]!=x3) {setverdict(pass);} //non-equality, not equals
+ else {setverdict(fail);}
+ if (not(x1[1]!='1'B)) {setverdict(pass);} //non-equality, equals
+ else {setverdict(fail);}
+}
+
+testcase bitstrComp_str_el() runs on bitstrOper_comptype
+{var bitstring x1,x2,x3;
+ x1:='0110'B;
+ x2:='1'B;
+ x3:='0'B;
+ if (x2==x1[1]) {setverdict(pass);} //equality, equals
+ else {setverdict(fail);}
+ if (not(x3==x1[1])) {setverdict(pass);} //equality, not equals
+ else {setverdict(fail);}
+ if (x2!=x1[0]) {setverdict(pass);} //non-equality, not equals
+ else {setverdict(fail);}
+ if (not('1'B!=x1[1])) {setverdict(pass);} //non-equality, equals
+ else {setverdict(fail);}
+}
+
+testcase bitstrComp_el_el() runs on bitstrOper_comptype
+{var bitstring x1,x2,x3;
+ x1:='0110'B;
+ x2:='0110'B;
+ x3:='011'B;
+ if (x1[2]==x2[2]) {setverdict(pass);} //equality, equals
+ else {setverdict(fail);}
+ if (not(x1[2]==x2[3])) {setverdict(pass);} //equality, not equals
+ else {setverdict(fail);}
+ if (x1[1]!=x3[0]) {setverdict(pass);} //non-equality, not equals
+ else {setverdict(fail);}
+ if (not(x1[1]!=x3[1])) {setverdict(pass);} //non-equality, equals
+ else {setverdict(fail);}
+}
+
+testcase bitstrConcat() runs on bitstrOper_comptype
+{var bitstring x1,x2,x3,x4,x5,x6,x7,x8;
+ x1:='0011'B;
+ x2:='1100'B;
+ x3:= x1 & x2;
+ x4:=x1&x2[3];
+ x5:=x1[1]&x2;
+ x6:=x1[2]&x2[1];
+ x7:='11111111000000001111111'B;
+ x8:=x1[0]&x7;
+ if ((x3=='00111100'B)and(lengthof(x3)==8)) {setverdict(pass);} //string_string
+ else {setverdict(fail);}
+ if ((x4=='00110'B)and(lengthof(x4)==5)) {setverdict(pass);} //string_element
+ else {setverdict(fail);}
+ if ((x5=='01100'B)and(lengthof(x5)==5)) {setverdict(pass);} //element_string
+ else {setverdict(fail);}
+ if ((x6=='11'B)and(lengthof(x6)==2)) {setverdict(pass);} //element_element
+ else {setverdict(fail);}
+ if((x8=='011111111000000001111111'B)and(lengthof(x8)==24)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrNot_str() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:='01101'B;
+ x2:=not4b(x1);
+ if (x2=='10010'B) {setverdict(pass);}
+ else {setverdict(fail);}
+ log(not4b(x1)); // HQ51603: the generated C++ must compile
+ action(not4b(x1)); // HQ51603
+}
+
+testcase bitstrNot_el() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3;
+ x1:='00111'B;
+ x2:=not4b(x1[1]);
+ x3:=not4b(x1[3]);
+ if (x2=='1'B) {setverdict(pass);} //not "0"
+ else {setverdict(fail);}
+ if (x3=='0'B) {setverdict(pass);} //not "1"
+ else {setverdict(fail);}
+}
+
+testcase bitstrAnd_str_str() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3;
+ x1:='01101'B;
+ x2:='00111'B;
+ x3:=x1 and4b x2;
+ if (x3=='00101'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrAnd_el_str() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3,x4,x5,x6;
+ x1:='0011'B;
+ x2:='1'B;
+ x3:=x1[0] and4b '0'B;
+ x4:=x1[0] and4b x2;
+ x5:=x1[2] and4b '0'B;
+ x6:=x1[3] and4b x2;
+ if (x3=='0'B) {setverdict(pass);} //"0" and "0"
+ else {setverdict(fail);}
+ if (x4=='0'B) {setverdict(pass);} //"0" and "1"
+ else {setverdict(fail);}
+ if (x5=='0'B) {setverdict(pass);} //"1" and "0"
+ else {setverdict(fail);}
+ if (x6=='1'B) {setverdict(pass);} //"1" and "1"
+ else {setverdict(fail);}
+}
+
+testcase bitstrAnd_str_el() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3,x4,x5,x6;
+ x1:='0011'B;
+ x2:='1'B;
+ x3:='0'B and4b x1[0];
+ x4:=x2 and4b x1[1];
+ x5:='0'B and4b x1[2];
+ x6:=x2 and4b x1[3];
+ if (x3=='0'B) {setverdict(pass);} //"0" and "0"
+ else {setverdict(fail);}
+ if (x4=='0'B) {setverdict(pass);} //"0" and "1"
+ else {setverdict(fail);}
+ if (x5=='0'B) {setverdict(pass);} //"1" and "0"
+ else {setverdict(fail);}
+ if (x6=='1'B) {setverdict(pass);} //"1" and "1"
+ else {setverdict(fail);}
+}
+
+testcase bitstrAnd_el_el() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3,x4,x5,x6;
+ x1:='0011'B;
+ x2:='0011'B;
+ x3:=x2[0] and4b x1[0];
+ x4:=x2[1] and4b x1[3];
+ x5:=x1[3] and4b x1[0];
+ x6:=x2[3] and4b x1[3];
+ if (x3=='0'B) {setverdict(pass);} //"0" and "0"
+ else {setverdict(fail);}
+ if (x4=='0'B) {setverdict(pass);} //"0" and "1"
+ else {setverdict(fail);}
+ if (x5=='0'B) {setverdict(pass);} //"1" and "0"
+ else {setverdict(fail);}
+ if (x6=='1'B) {setverdict(pass);} //"1" and "1"
+ else {setverdict(fail);}
+}
+
+testcase bitstrOr_str_str() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3;
+ x1:='01101'B;
+ x2:='00111'B;
+ x3:=x1 or4b x2;
+ if (x3=='01111'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrOr_el_str() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3,x4,x5,x6;
+ x1:='0011'B;
+ x2:='1'B;
+ x3:=x1[0] or4b '0'B;
+ x4:=x1[0] or4b x2;
+ x5:=x1[2] or4b '0'B;
+ x6:=x1[3] or4b x2;
+ if (x3=='0'B) {setverdict(pass);} //"0" or "0"
+ else {setverdict(fail);}
+ if (x4=='1'B) {setverdict(pass);} //"0" or "1"
+ else {setverdict(fail);}
+ if (x5=='1'B) {setverdict(pass);} //"1" or "0"
+ else {setverdict(fail);}
+ if (x6=='1'B) {setverdict(pass);} //"1" or "1"
+ else {setverdict(fail);}
+}
+
+testcase bitstrOr_str_el() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3,x4,x5,x6;
+ x1:='0011'B;
+ x2:='1'B;
+ x3:='0'B or4b x1[0];
+ x4:=x2 or4b x1[1];
+ x5:='0'B or4b x1[2];
+ x6:=x2 or4b x1[3];
+ if (x3=='0'B) {setverdict(pass);} //"0" or "0"
+ else {setverdict(fail);}
+ if (x4=='1'B) {setverdict(pass);} //"0" or "1"
+ else {setverdict(fail);}
+ if (x5=='1'B) {setverdict(pass);} //"1" or "0"
+ else {setverdict(fail);}
+ if (x6=='1'B) {setverdict(pass);} //"1" or "1"
+ else {setverdict(fail);}
+}
+
+testcase bitstrOr_el_el() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3,x4,x5,x6;
+ x1:='0011'B;
+ x2:='0011'B;
+ x3:=x2[0] or4b x1[0];
+ x4:=x2[1] or4b x1[3];
+ x5:=x1[3] or4b x1[0];
+ x6:=x2[3] or4b x1[3];
+ if (x3=='0'B) {setverdict(pass);} //"0" or "0"
+ else {setverdict(fail);}
+ if (x4=='1'B) {setverdict(pass);} //"0" or "1"
+ else {setverdict(fail);}
+ if (x5=='1'B) {setverdict(pass);} //"1" or "0"
+ else {setverdict(fail);}
+ if (x6=='1'B) {setverdict(pass);} //"1" or "1"
+ else {setverdict(fail);}
+}
+
+testcase bitstrXor_str_str() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3;
+ x1:='01101'B;
+ x2:='00111'B;
+ x3:=x1 xor4b x2;
+ if (x3=='01010'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrXor_el_str() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3,x4,x5,x6;
+ x1:='0011'B;
+ x2:='1'B;
+ x3:=x1[0] xor4b '0'B;
+ x4:=x1[0] xor4b x2;
+ x5:=x1[2] xor4b '0'B;
+ x6:=x1[3] xor4b x2;
+ if (x3=='0'B) {setverdict(pass);} //"0" xor "0"
+ else {setverdict(fail);}
+ if (x4=='1'B) {setverdict(pass);} //"0" xor "1"
+ else {setverdict(fail);}
+ if (x5=='1'B) {setverdict(pass);} //"1" xor "0"
+ else {setverdict(fail);}
+ if (x6=='0'B) {setverdict(pass);} //"1" xor "1"
+ else {setverdict(fail);}
+}
+
+testcase bitstrXor_str_el() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3,x4,x5,x6;
+ x1:='0011'B;
+ x2:='1'B;
+ x3:='0'B xor4b x1[0];
+ x4:=x2 xor4b x1[1];
+ x5:='0'B xor4b x1[2];
+ x6:=x2 xor4b x1[3];
+ if (x3=='0'B) {setverdict(pass);} //"0" xor "0"
+ else {setverdict(fail);}
+ if (x4=='1'B) {setverdict(pass);} //"0" xor "1"
+ else {setverdict(fail);}
+ if (x5=='1'B) {setverdict(pass);} //"1" xor "0"
+ else {setverdict(fail);}
+ if (x6=='0'B) {setverdict(pass);} //"1" xor "1"
+ else {setverdict(fail);}
+}
+
+testcase bitstrXor_el_el() runs on bitstrOper_comptype
+{ var bitstring x1,x2,x3,x4,x5,x6;
+ x1:='0011'B;
+ x2:='0011'B;
+ x3:=x2[0] xor4b x1[0];
+ x4:=x2[1] xor4b x1[3];
+ x5:=x1[3] xor4b x1[0];
+ x6:=x2[3] xor4b x1[3];
+ if (x3=='0'B) {setverdict(pass);} //"0" xor "0"
+ else {setverdict(fail);}
+ if (x4=='1'B) {setverdict(pass);} //"0" xor "1"
+ else {setverdict(fail);}
+ if (x5=='1'B) {setverdict(pass);} //"1" xor "0"
+ else {setverdict(fail);}
+ if (x6=='0'B) {setverdict(pass);} //"1" xor "1"
+ else {setverdict(fail);}
+}
+
+testcase bitstrShiftRight1() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:='01101'B;
+ x2:=x1 >> 1;
+ if (x2=='00110'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrShiftRight2() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:='01101'B;
+ x2:=x1 >> 2;
+ if (x2=='00011'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrShiftRightSum() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:='01101'B;
+ x2:=x1 >> (1+1);
+ if (x2=='00011'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrShiftRightEmpty() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:=''B;
+ x2:=x1 >> 1;
+ if (x2==''B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrShiftLeft1() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:='01101'B;
+ x2:=x1 << 1;
+ if (x2=='11010'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrShiftLeft2() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:='01101'B;
+ x2:=x1 << 2;
+ if (x2=='10100'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrShiftLeftSum() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:='01101'B;
+ x2:=x1 << (1+1);
+ if (x2=='10100'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrShiftLeftEmpty() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:=''B;
+ x2:=x1 << 1;
+ if (x2==''B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrRotateRight1() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:='01101'B;
+ x2:=x1 @> 1;
+ if (x2=='10110'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrRotateRight2() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:='01101'B;
+ x2:=x1 @> 2;
+ if (x2=='01011'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrRotateRightSum() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:='01101'B;
+ x2:=x1 @> (1+1);
+ if (x2=='01011'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrRotateRightEmpty() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:=''B;
+ x2:=x1 @> 1;
+ if (x2==''B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrRotateLeft1() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:='01101'B;
+ x2:=x1 <@ 1;
+ if (x2=='11010'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrRotateLeft2() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:='01101'B;
+ x2:=x1 <@ 2;
+ if (x2=='10101'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrRotateLeftSum() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:='01101'B;
+ x2:=x1 <@ (1+1);
+ if (x2=='10101'B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase bitstrRotateLeftEmpty() runs on bitstrOper_comptype
+{ var bitstring x1,x2;
+ x1:=''B;
+ x2:=x1 <@ 1;
+ if (x2==''B) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+type bitstring mybstr1
+type mybstr1 mybstr2
+type mybstr1 mybstr3 ('0'B, '1'B)
+type mybstr1 mybstr4 ('0'B, '1'B) length(1)
+type mybstr1 mybstr5 length(1)
+type mybstr1 mybstr6 (int2bit(512, 11), int2bit(1024, 11))
+// Length 0.
+type bitstring mybstr7 length(0..0)
+type bitstring MyByte length(8..8)
+type bitstring MyNibbleToByte length(4..8)
+type bitstring BitStrings1 ('0'B, '1'B)
+type bitstring BitStrings2 ('00'B, '01'B, '10'B, '10'B)
+type bitstring BitStrings_1_2 (BitStrings1, BitStrings2)
+type bitstring mybstr8 (mybstr3, mybstr4)
+type bitstring mybstr9 length(0..infinity) // Full set.
+
+const mybstr4 c_mybstr1 := '0'B
+const mybstr8 c_mybstr2 := c_mybstr1
+
+template mybstr4 t_mybstr1 := '0'B
+template mybstr8 t_mybstr2 := t_mybstr1
+template mybstr7 t_mybstr3 := ''B length(0)
+
+function f_bstr1() return mybstr3 {
+ var mybstr2 v_mybstr1 := int2bit(bit2int('0'B), 1)
+ var template mybstr4 vt_mybstr1 := '1'B
+ // `vt_mybstr1[0] := '0'B' doesn't compile. T_REFD nodes were not handled
+ // in the fix for TR 921.
+ return substr(v_mybstr1 & valueof(vt_mybstr1), 0, 1)
+}
+
+testcase bitstrSubtypes(in template mybstr3 p1) runs on bitstrOper_comptype {
+ var template mybstr3 vt_mybstr1 := '0'B // Value list.
+ var template mybstr4 vt_mybstr2 := '0'B // Length with value list.
+ var template mybstr5 vt_mybstr3 := '0'B // Length only.
+ var mybstr3 v_mybstr1 := valueof(vt_mybstr1)
+ var mybstr4 v_mybstr2 := valueof(vt_mybstr2)
+ var mybstr5 v_mybstr3 := valueof(vt_mybstr3)
+
+ if (valueof(vt_mybstr1) == v_mybstr1 and v_mybstr2 == valueof(vt_mybstr2)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (valueof(vt_mybstr3) == v_mybstr3) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (f_bstr1() == c_mybstr1 and '0'B == f_bstr1()) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+testcase bitstrIsvalue() runs on bitstrOper_comptype{
+ var bitstring ostr0;
+ var bitstring ostr1 := '1111'B;
+ var template bitstring tostr;
+
+ if ( isvalue(ostr0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(ostr1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(tostr) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+testcase bitstrIsbound() runs on bitstrOper_comptype{
+ var bitstring ostr0;
+ var bitstring ostr1 := '1111'B;
+ var template bitstring tostr;
+
+ if ( isbound(ostr0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(ostr0[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(ostr1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(tostr) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+ control
+ {
+ const bitstring cl_1:='1000'B;
+ var bitstring vl_1;
+
+ execute(bitstrAssign());
+ execute(bitstrAssignElem10());
+ execute(bitstrAssignElem01());
+ execute(bitstrAssignElem00());
+ execute(bitstrAssignElem11());
+ execute(bitstrAssignElemAdd());
+ execute(bitstrLengthof());
+ execute(bitstrConst());
+ execute(bitstrComp_str_str());
+ execute(bitstrComp_el_str());
+ execute(bitstrComp_str_el());
+ execute(bitstrComp_el_el());
+ execute(bitstrConcat());
+ execute(bitstrNot_str());
+ execute(bitstrNot_el());
+ execute(bitstrAnd_str_str());
+ execute(bitstrAnd_el_str());
+ execute(bitstrAnd_str_el());
+ execute(bitstrAnd_el_el());
+ execute(bitstrOr_str_str());
+ execute(bitstrOr_el_str());
+ execute(bitstrOr_str_el());
+ execute(bitstrOr_el_el());
+ execute(bitstrXor_str_str());
+ execute(bitstrXor_el_str());
+ execute(bitstrXor_str_el());
+ execute(bitstrXor_el_el());
+ execute(bitstrShiftRight1());
+ execute(bitstrShiftRight2());
+ execute(bitstrShiftRightSum());
+ execute(bitstrShiftRightEmpty());
+ execute(bitstrShiftLeft1());
+ execute(bitstrShiftLeft2());
+ execute(bitstrShiftLeftSum());
+ execute(bitstrShiftLeftEmpty());
+ execute(bitstrRotateRight1());
+ execute(bitstrRotateRight2());
+ execute(bitstrRotateRightSum());
+ execute(bitstrRotateRightEmpty());
+ execute(bitstrRotateLeft1());
+ execute(bitstrRotateLeft2());
+ execute(bitstrRotateLeftSum());
+ execute(bitstrRotateLeftEmpty());
+ execute(bitstrSubtypes('0'B));
+ execute(bitstrIsvalue());
+ execute(bitstrIsbound());
+ }
+}
diff --git a/Regression_Test_java/src/TboolOper.ttcn b/Regression_Test_java/src/TboolOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..015f554caa01aa8caded920fded99081b1d5842d
--- /dev/null
+++ b/Regression_Test_java/src/TboolOper.ttcn
@@ -0,0 +1,399 @@
+/******************************************************************************
+ * 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
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TboolOper
+{const boolean TboolOper_const1:=true;
+type component boolOper_comptype { };
+
+testcase boolAssign() runs on boolOper_comptype
+{ var boolean x1:=true;
+ var boolean x4:=x1;
+ var boolean x2,x3;
+ x2:=false;
+ x3:=x2;
+ if (x1) {setverdict(pass);} //at declaration, value
+ else {setverdict(fail);}
+ if (x4) {setverdict(pass);} //at declaration, variable
+ else {setverdict(fail);}
+ if (not(x2)) {setverdict(pass);} //later, value
+ else {setverdict(fail);}
+ if (not(x3)) {setverdict(pass);} //later, variable
+ else {setverdict(fail);}
+}
+
+testcase boolConst() runs on boolOper_comptype {
+const boolean TboolOper_const3:=false;
+if (TboolOper_const1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+//if (TboolOper_const2==2) {setverdict(pass);} //control part
+// else {setverdict(fail);}
+if (not(TboolOper_const3)) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+}
+
+testcase boolCompEq() runs on boolOper_comptype
+{ var boolean x1,x2,x3;
+ x1:=true;
+ x2:=true;
+ x3:=false;
+ if (x1==x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x3==x2)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1==true) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1==false)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (true==x1) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(false==x1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (true==true) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(true==false)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase boolCompNotEq() runs on boolOper_comptype
+{ var boolean x1,x2,x3;
+ x1:=true;
+ x2:=false;
+ x3:=true;
+ if (x1!=x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x1!=x3)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1!=false) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1!=true)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (true!=x2) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(false!=x2)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (true!=false) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(false!=false)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase boolNot() runs on boolOper_comptype
+{ var boolean x1,x2,x3,x4,x5,x6;
+ x1:=true;
+ x2:=false;
+ x3:=not(x1);
+ x4:=not(x2);
+ x5:=not(true);
+ x6:=not(false);
+ if (not(x3)) {setverdict(pass);} //variable
+ else {setverdict(fail);}
+ if (x4) {setverdict(pass);} //variable
+ else {setverdict(fail);}
+ if (not(x5)) {setverdict(pass);} //value
+ else {setverdict(fail);}
+ if (x6) {setverdict(pass);} //value
+ else {setverdict(fail);}
+}
+
+testcase boolAnd() runs on boolOper_comptype
+{ var boolean x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18;
+ x1:=true;
+ x2:=false;
+ x3:=x1 and x1;
+ x4:=x1 and x2;
+ x5:=x2 and x1;
+ x6:=x2 and x2;
+ x7:=x1 and true;
+ x8:=x1 and false;
+ x9:=x2 and true;
+ x10:=x2 and false;
+ x11:=true and x1;
+ x12:=true and x2;
+ x13:=false and x1;
+ x14:=false and x2;
+ x15:=true and true;
+ x16:=true and false;
+ x17:=false and true;
+ x18:=false and false;
+ if (x3) {setverdict(pass);} //variable_variable
+ else {setverdict(fail,"1");}
+ if (not(x4)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail, "2");}
+ if (not(x5)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail, "3");}
+ if (not(x6)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail, "4");}
+ if (x7) {setverdict(pass);} //variable_value
+ else {setverdict(fail, "5");}
+ if (not(x8)) {setverdict(pass);} //variable_value
+ else {setverdict(fail, "6");}
+ if (not(x9)) {setverdict(pass);} //variable_value
+ else {setverdict(fail, "7");}
+ if (not(x10)) {setverdict(pass);} //variable_value
+ else {setverdict(fail, "8");}
+ if (x11) {setverdict(pass);} //value_variable
+ else {setverdict(fail,"9" );}
+ if (not(x12)) {setverdict(pass);} //value_variable
+ else {setverdict(fail, "10");}
+ if (not(x13)) {setverdict(pass);} //value_variable
+ else {setverdict(fail, "11");}
+ if (not(x14)) {setverdict(pass);} //value_variable
+ else {setverdict(fail, "12");}
+ if (x15) {setverdict(pass);} //value_value
+ else {setverdict(fail, "13");}
+ if (not(x16)) {setverdict(pass);} //value_value
+ else {setverdict(fail, "14");}
+ if (not(x17)) {setverdict(pass);} //value_value
+ else {setverdict(fail, "15");}
+ if (not(x18)) {setverdict(pass);} //value_value
+ else {setverdict(fail, "16");}
+}
+
+testcase boolOr() runs on boolOper_comptype
+{ var boolean x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18;
+ x1:=true;
+ x2:=false;
+ x3:=x1 or x1;
+ x4:=x1 or x2;
+ x5:=x2 or x1;
+ x6:=x2 or x2;
+ x7:=x1 or true;
+ x8:=x1 or false;
+ x9:=x2 or true;
+ x10:=x2 or false;
+ x11:=true or x1;
+ x12:=true or x2;
+ x13:=false or x1;
+ x14:=false or x2;
+ x15:=true or true;
+ x16:=true or false;
+ x17:=false or true;
+ x18:=false or false;
+ if (x3) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x4) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x5) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x6)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x7) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x8) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x9) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x10)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x11) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x12) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x13) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(x14)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x15) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (x16) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (x17) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(x18)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase boolXor() runs on boolOper_comptype
+{ var boolean x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18;
+ x1:=true;
+ x2:=false;
+ x3:=x1 xor x1;
+ x4:=x1 xor x2;
+ x5:=x2 xor x1;
+ x6:=x2 xor x2;
+ x7:=x1 xor true;
+ x8:=x1 xor false;
+ x9:=x2 xor true;
+ x10:=x2 xor false;
+ x11:=true xor x1;
+ x12:=true xor x2;
+ x13:=false xor x1;
+ x14:=false xor x2;
+ x15:=true xor true;
+ x16:=true xor false;
+ x17:=false xor true;
+ x18:=false xor false;
+ if (not(x3)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x4) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x5) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x6)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x7)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x8) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x9) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x10)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x11)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x12) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x13) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(x14)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(x15)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (x16) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (x17) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(x18)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+type boolean myb1
+type boolean myb2 (true)
+type boolean myb3 (false)
+// FATAL_ERROR() with R8B: `type boolean myb3 (true, valueof(t_myb1))'.
+type boolean myb4 (c_myb1, not c_myb1 and c_myb1)
+type myb3 myb5
+type boolean myb6 (myb2, myb3)
+
+const boolean c_myb1 := true
+const myb6 c_myb2 := c_myb1
+
+template boolean t_myb1 := true
+template myb6 t_myb2 := t_myb1
+
+function f_b1(in boolean p1) return boolean { return p1 }
+
+function f_b2() return myb4 {
+ var template boolean vt_myb1 := t_myb1
+ if (valueof(t_myb1) and valueof(vt_myb1)) { return true }
+ else { return false }
+}
+
+function f_b3() return myb4 {
+ var myb4 v_myb1 := false
+ var template myb4 vt_myb1 := c_myb1
+ if (not v_myb1 and valueof(vt_myb1) == true) { return true }
+ else { return false }
+}
+
+testcase boolSubtypes() runs on boolOper_comptype {
+ if (f_b1(c_myb1) == f_b2()) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+testcase boolIsvalue() runs on boolOper_comptype{
+ var template boolean vt0;
+ var template boolean vt1 := ( true, true, true );
+
+ if ( isvalue(vt0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(vt1) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+type union TestUnion {
+ integer t,
+ boolean b
+}
+
+type record TestRecord {
+ integer t,
+ boolean b optional
+}
+
+// for TR fix HT60781
+testcase boolShortCircuit() runs on boolOper_comptype {
+ // create a union variable, make sure the boolean field is not chosen
+ var TestUnion myUnion := { t := 1 };
+
+ // reference the boolean field in the 2nd part of a condition using 'and' or 'or'
+ // only the first part of the condition should be evaluated, since
+ // evaluating the 2nd part would produce a DTE (because the field isn't chosen)
+ if (ischosen(myUnion.b) and myUnion.b) {
+ setverdict(fail, "Error in 'if' condition, field 'b' is not supposed to be chosen");
+ }
+ while (ischosen(myUnion.b) and myUnion.b) {
+ setverdict(fail, "Error in 'while' condition, field 'b' is not supposed to be chosen");
+ }
+ var integer i;
+ for (i := 0; ischosen(myUnion.b) and myUnion.b and i < 5; i := i + 1) {
+ setverdict(fail, "Error in 'for' condition, field 'b' is not supposed to be chosen");
+ }
+ var boolean res := not ischosen(myUnion.b) or myUnion.b;
+ if (not res) {
+ setverdict(fail, "Error in boolean assignment, field 'b' is not supposed to be chosen");
+ }
+
+ // create a record variable, make sure the boolean field is omitted
+ var TestRecord myRec := { t := 1, b := omit };
+
+ // reference the boolean field in the 2nd part of a condition, same as with the union field
+ // (referencing the boolean field would cause a DTE again, because it is omitted)
+ if (ispresent(myRec.b) and myRec.b) {
+ setverdict(fail, "Error in 'if' condition, field 'b' is not supposed to be present");
+ }
+ while (ispresent(myRec.b) and myRec.b) {
+ setverdict(fail, "Error in 'if' condition, field 'b' is not supposed to be present");
+ }
+ for (i := 0; ispresent(myRec.b) and myRec.b and i < 5; i := i + 1) {
+ setverdict(fail, "Error in 'for' condition, field 'b' is not supposed to be present");
+ }
+ res := not ispresent(myRec.b) or myRec.b;
+ if (not res) {
+ setverdict(fail, "Error in boolean assignment, field 'b' is not supposed to be present");
+ }
+ setverdict(pass);
+}
+
+type record MyRecord {
+ integer a optional
+}
+
+// comparing an optional record field to 'omit' in a boolean variable assignment (bug 498430)
+testcase boolCompEqOmit() runs on boolOper_comptype {
+ var MyRecord myRecord := { a := omit };
+ var boolean b := myRecord.a == omit;
+ if (b == true) { setverdict(pass); }
+ else { setverdict(fail); }
+}
+
+control {
+ const boolean cl_1:=true;
+ var boolean vl_1;
+
+ execute(boolAssign());
+ execute(boolConst());
+ execute(boolCompEq());
+ execute(boolCompNotEq());
+ execute(boolNot());
+ execute(boolAnd());
+ execute(boolOr());
+ execute(boolXor());
+ execute(boolSubtypes());
+ execute(boolIsvalue());
+ execute(boolShortCircuit());
+ execute(boolCompEqOmit());
+}
+
+}
diff --git a/Regression_Test_java/src/TcharOper.ttcn b/Regression_Test_java/src/TcharOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..467239bda70050b38b72c93fc4daeb7a3a3cba4b
--- /dev/null
+++ b/Regression_Test_java/src/TcharOper.ttcn
@@ -0,0 +1,102 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+
+// char type is no longer a standalone type, it maps to charstring in the standard
+module TcharOper
+{
+type char typedefbasic_mychar;
+const char TcharOper_const1:="h";
+type component charOper_comptype { };
+
+testcase charAssign() runs on charOper_comptype
+{ var char x1:="a";
+ var char x4:=x1;
+ var char x2,x3;
+ x2:="x";
+ x3:=x2;
+ if (x1=="a") {setverdict(pass);} //at declaration, value
+ else {setverdict(fail);}
+ if (x4=="a") {setverdict(pass);} //at declaration, variable
+ else {setverdict(fail);}
+ if (x2=="x") {setverdict(pass);} //later, value
+ else {setverdict(fail);}
+ if (x3=="x") {setverdict(pass);} //later, variable
+ else {setverdict(fail);}
+}
+
+testcase charConst() runs on charOper_comptype {
+const char TcharOper_const3:="1";
+if (TcharOper_const1=="h") {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+//if (TcharOper_const2==2) {setverdict(pass);} //control part
+// else {setverdict(fail);}
+if (TcharOper_const3=="1") {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+}
+
+testcase charCompEq() runs on charOper_comptype
+{ var char x1,x2,x3;
+ x1:="a";
+ x2:="a";
+ x3:="c";
+ if (x1==x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x3==x2)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1=="a") {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1=="v")) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if ("a"==x1) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not("4"==x1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if ("a"=="a") {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not("c"=="a")) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase charCompNotEq() runs on charOper_comptype
+{ var char x1,x2,x3;
+ x1:="a";
+ x2:="k";
+ x3:="a";
+ if (x1!=x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x1!=x3)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1!="l") {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1!="a")) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if ("m"!=x2) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not("k"!=x2)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if ("a"!="b") {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not("1"!="1")) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+control {
+ execute(charAssign());
+ execute(charConst());
+ execute(charCompEq());
+ execute(charCompNotEq());
+}
+
+}
diff --git a/Regression_Test_java/src/TcharstrOper.ttcn b/Regression_Test_java/src/TcharstrOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..e9d2479ad3765d107597da2602de2309f02ea877
--- /dev/null
+++ b/Regression_Test_java/src/TcharstrOper.ttcn
@@ -0,0 +1,555 @@
+/******************************************************************************
+ * 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
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TcharstrOper
+{type component charstrOper_comptype { };
+const charstring TcharstrOper_const1:="asd1";
+
+testcase charstrAssign() runs on charstrOper_comptype
+{ var charstring x1:="ABCD";
+ var charstring x5:=x1;
+ var charstring x2,x3,x4,x6;
+ x2:="1234";
+ x6:=x2;
+ x4:="ab12";
+ x3:="";
+ x4:="ab123";
+ if (x1=="ABCD") {setverdict(pass);} //at declaration, with value
+ else {setverdict(fail);}
+ if (x5=="ABCD") {setverdict(pass);} //at declaration, with variable
+ else {setverdict(fail);}
+ if (x2=="1234") {setverdict(pass);} //later, with value
+ else {setverdict(fail);}
+ if (x6=="1234") {setverdict(pass);} //later, with variable
+ else {setverdict(fail);}
+ if (x3=="") {setverdict(pass);} //empty string
+ else {setverdict(fail);}
+ if (x4=="ab123") {setverdict(pass);} //change of size
+ else {setverdict(fail);}
+}
+
+// testcase charstrAssignQuote() runs on charstrOper_comptype
+//{ var charstring x1;
+// x1:="ab""12";
+// if ((x1=="ab""12")) {setverdict(pass);}
+// else {setverdict(fail);}
+//}
+
+
+testcase charstrAssignElem() runs on charstrOper_comptype
+{ var charstring x1,x2,x3,x4,x5,x6;
+ x1:="AAAAAA";
+ x4:="AAAAAA";
+ x2:="AAAAAA";
+ x5:="abcdef";
+ x6:="AAAAAA"
+ x3:="ab";
+ x3:=x5[1];
+ x1[1]:="b";
+ x2[2]:=x3;
+ x4[1]:=x5[2];
+ x6[6]:="B";
+ if (x5[1]=="b") {setverdict(pass);} //accessing an element
+ else {setverdict(fail);}
+ if (x3=="b") {setverdict(pass);} //change string to element
+ else {setverdict(fail);}
+ if (x1=="AbAAAA") {setverdict(pass);} //change element to value
+ else {setverdict(fail);}
+ if (x4=="AcAAAA") {setverdict(pass);} //change element to element
+ else {setverdict(fail);}
+ if (x2=="AAbAAA") {setverdict(pass);} //change element to string
+ else {setverdict(fail);}
+ if (x6=="AAAAAAB") {setverdict(pass);} //add element to string
+ else {setverdict(fail);}
+}
+
+testcase charstrLengthof() runs on charstrOper_comptype
+{ var charstring x1:="ABCD";
+ var charstring x6:=x1;
+ var charstring x2,x3,x4,x5,x7;
+ x2:="1234";
+ x7:=x2;
+ x4:="ab12";
+ x5:="abcd";
+ x3:="";
+ x4:="ab123";
+ x5[4]:="e";
+ if (lengthof(x1)==4) {setverdict(pass);} //at declaration, with value
+ else {setverdict(fail);}
+ if (lengthof(x6)==4) {setverdict(pass);} //at declaration, with variable
+ else {setverdict(fail);}
+ if (lengthof(x2)==4) {setverdict(pass);} //later, with value
+ else {setverdict(fail);}
+ if (lengthof(x7)==4) {setverdict(pass);} //later, with variable
+ else {setverdict(fail);}
+ if (lengthof(x3)==0) {setverdict(pass);} //empty string
+ else {setverdict(fail);}
+ if (lengthof(x4)==5) {setverdict(pass);} //change of size by assignment
+ else {setverdict(fail);}
+ if (lengthof(x5)==5) {setverdict(pass);} //change of size by adding element
+ else {setverdict(fail);}
+}
+
+testcase charstrAssignElemAdd() runs on charstrOper_comptype
+{ var charstring x1,x2,x3,x4,x5;
+ x1:="AAAAAA";
+ x4:="AAAAAA";
+ x2:="AAAAAA";
+ x3:="b";
+ x5:="abcdef";
+ x1[6]:="b";
+ x2[6]:=x3;
+ x4[6]:=x5[2];
+ if ((x1=="AAAAAAb")and(lengthof(x1)==7)) {setverdict(pass);} //add value
+ else {setverdict(fail);}
+ if ((x2=="AAAAAAb")and(lengthof(x2)==7)) {setverdict(pass);} //add string
+ else {setverdict(fail);}
+ if ((x4=="AAAAAAc")and(lengthof(x4)==7)) {setverdict(pass);} //add element
+ else {setverdict(fail);}
+}
+
+testcase charstrConst() runs on charstrOper_comptype {
+const charstring TcharstrOper_const3:="klm";
+if (TcharstrOper_const1=="asd1") {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (TcharstrOper_const3=="klm") {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+}
+
+testcase charstrCompEq() runs on charstrOper_comptype
+{ var charstring x1,x2,x3,x4,x5;
+ x1:="abc";
+ x2:="abc";
+ x3:="cde";
+ x4:="d";
+ if (x1==x2) {setverdict(pass);} //string_string
+ else {setverdict(fail);}
+ if (not(x1==x3)) {setverdict(pass);} //string_string
+ else {setverdict(fail);}
+ if (x4==x3[1]) {setverdict(pass);} //string_element
+ else {setverdict(fail);}
+ if (not(x4==x3[0])) {setverdict(pass);} //string_element
+ else {setverdict(fail);}
+ if (x1=="abc") {setverdict(pass);} //string_value
+ else {setverdict(fail);}
+ if (not(x1=="aabc")) {setverdict(pass);} //string_value
+ else {setverdict(fail);}
+ if (x3[1]==x4) {setverdict(pass);} //element_string
+ else {setverdict(fail);}
+ if (not(x3[2]==x4)) {setverdict(pass);} //element_string
+ else {setverdict(fail);}
+ if (x1[1]==x2[1]) {setverdict(pass);} //element_element
+ else {setverdict(fail);}
+ if (not(x1[0]==x2[1])) {setverdict(pass);} //element_element
+ else {setverdict(fail);}
+ if (x3[2]=="e") {setverdict(pass);} //element_value
+ else {setverdict(fail);}
+ if (not(x3[2]=="f")) {setverdict(pass);} //element_value
+ else {setverdict(fail);}
+ if ("abc"==x2) {setverdict(pass);} //value_string
+ else {setverdict(fail);}
+ if (not("dbc"==x2)) {setverdict(pass);} //value_string
+ else {setverdict(fail);}
+ if ("d"==x3[1]) {setverdict(pass);} //value_element
+ else {setverdict(fail);}
+ if (not("k"==x3[1])) {setverdict(pass);} //value_element
+ else {setverdict(fail);}
+// if ("df"=="df") {setverdict(pass);} //value_value
+// else {setverdict(fail);}
+// if (not("dh"=="df")) {setverdict(pass);} //value_value
+// else {setverdict(fail);}
+}
+
+testcase charstrCompNotEq() runs on charstrOper_comptype
+{ var charstring x1,x2,x3,x4,x5;
+ x1:="abc";
+ x2:="abc";
+ x3:="cde";
+ x4:="d";
+ if (not(x1!=x2)) {setverdict(pass);} //string_string
+ else {setverdict(fail);}
+ if (x1!=x3) {setverdict(pass);} //string_string
+ else {setverdict(fail);}
+ if (not(x4!=x3[1])) {setverdict(pass);} //string_element
+ else {setverdict(fail);}
+ if (x4!=x3[2]) {setverdict(pass);} //string_element
+ else {setverdict(fail);}
+ if (not(x1!="abc")) {setverdict(pass);} //string_value
+ else {setverdict(fail);}
+ if (x1!="ab") {setverdict(pass);} //string_value
+ else {setverdict(fail);}
+ if (not(x3[1]!=x4)) {setverdict(pass);} //element_string
+ else {setverdict(fail);}
+ if (x1[1]!=x4) {setverdict(pass);} //element_string
+ else {setverdict(fail);}
+ if (not(x1[1]!=x2[1])) {setverdict(pass);} //element_element
+ else {setverdict(fail);}
+ if (x1[1]!=x3[1]) {setverdict(pass);} //element_element
+ else {setverdict(fail);}
+ if (not(x3[2]!="e")) {setverdict(pass);} //element_value
+ else {setverdict(fail);}
+ if (x3[2]!="F") {setverdict(pass);} //element_value
+ else {setverdict(fail);}
+ if (not("abc"!=x2)) {setverdict(pass);} //value_string
+ else {setverdict(fail);}
+ if ("abcD"!=x2) {setverdict(pass);} //value_string
+ else {setverdict(fail);}
+ if (not("b"!=x1[1])) {setverdict(pass);} //value_element
+ else {setverdict(fail);}
+ if ("d"!=x1[1]) {setverdict(pass);} //value_element
+ else {setverdict(fail);}
+// if (not("ef"!="ef")) {setverdict(pass);} //value_value
+// else {setverdict(fail);}
+// if ("d"!="ef") {setverdict(pass);} //value_value
+// else {setverdict(fail);}
+}
+
+//testcase charstrCompSmall() runs on charstrOper_comptype
+//{ var charstring x1,x2,x3,x4,x5;
+// x1:="cde";
+// x2:="abc";
+// x3:="cde";
+// x4:="ghi";
+// x5:="d";
+// if (x3<x4) {setverdict(pass);} //string_string
+// else {setverdict(fail);}
+// if ((not(x1<x2))and(not(x1<x3))and(x1<x4)) {setverdict(pass);} //string_string
+// else {setverdict(fail);}
+// if ((not(x5<x3[0]))and(not(x5<x3[1]))and(x5<x3[2])) {setverdict(pass);} //string_element
+// else {setverdict(fail);}
+// if ((not(x1<"abc"))and(not(x1<"cde"))and(x1<"ghi")) {setverdict(pass);} //string_value
+// else {setverdict(fail);}
+// if ((not(x3[2]<x5))and(not(x3[1]<x5))and(x3[0]<x5)) {setverdict(pass);} //element_string
+// else {setverdict(fail);}
+// if ((not(x3[2]<x1[1]))and(not(x3[1]<x1[1]))and(x3[0]<x1[1])) {setverdict(pass);} //element_element
+// else {setverdict(fail);}
+// if ((not(x3[2]<"d"))and(not(x3[1]<"e"))and(x3[0]<"fg")) {setverdict(pass);} //element_value
+// else {setverdict(fail);}
+// if ((not("de"<x2))and(not("abc"<x2))and("ab"<x2)) {setverdict(pass);} //value_string
+// else {setverdict(fail);}
+// if ("de"<x1[1]) {setverdict(pass);} //value_element
+// else {setverdict(fail);}
+// if ("de"<"ef") {setverdict(pass);} //value_value
+// else {setverdict(fail);}
+//}
+
+//testcase charstrCompBig() runs on charstrOper_comptype
+//{ var charstring x1,x2,x3,x4,x5;
+// x1:="cde";
+// x2:="abc";
+// x3:="cde";
+// x4:="ghi";
+// x5:="d";
+// if ((not(x2>x1))and(not(x3>x1))and(x4>x1)) {setverdict(pass);} //string_string
+// else {setverdict(fail);}
+// if ((not("abc">x1))and(not("cde">x1))and("ghi">x1)) {setverdict(pass);} //value_string
+// else {setverdict(fail);}
+// if ((not(x2>"de"))and(not(x2>"abc"))and(x2>"ab")) {setverdict(pass);} //string_value
+// else {setverdict(fail);}
+//}
+
+testcase charstrConcat() runs on charstrOper_comptype
+{var charstring x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11;
+ x1:="ABCD";
+ x2:="1234";
+ x3:= x1 & x2;
+ x4:=x1&x2[1];
+ x5:=x1[1]&x2;
+ x6:=x1[0]&x2[1];
+ x7:=x1&"1234";
+ x8:=x1[1]&"1234";
+ x9:="1234"&x1;
+ x10:="1234"&x1[1];
+// x11:="1234"&"ABCD";
+ if ((x3=="ABCD1234")and(lengthof(x3)==8)) {setverdict(pass);} //string&string
+ else {setverdict(fail);}
+ if ((x4=="ABCD2")and(lengthof(x4)==5)) {setverdict(pass);} //string&element
+ else {setverdict(fail);}
+ if ((x7=="ABCD1234")and(lengthof(x7)==8)) {setverdict(pass);} //string&value
+ else {setverdict(fail);}
+ if ((x5=="B1234")and(lengthof(x5)==5)) {setverdict(pass);} //element&string
+ else {setverdict(fail);}
+ if ((x6=="A2")and(lengthof(x6)==2)) {setverdict(pass);} //element&element
+ else {setverdict(fail);}
+ if ((x8=="B1234")and(lengthof(x8)==5)) {setverdict(pass);} //element&value
+ else {setverdict(fail);}
+ if ((x9=="1234ABCD")and(lengthof(x9)==8)) {setverdict(pass);} //value&string
+ else {setverdict(fail);}
+ if ((x10=="1234B")and(lengthof(x10)==5)) {setverdict(pass);} //value&element
+ else {setverdict(fail);}
+// if ((x11=="1234ABCD")and(lengthof(x11)==8)) {setverdict(pass);} //value&value
+// else {setverdict(fail);}
+}
+
+testcase charstrRotateRight1() runs on charstrOper_comptype
+{ var charstring x1,x2,x3;
+ x1:="ABCDEF";
+ x2:=x1 @> 1;
+// x3:="FABCDE" @> 1;
+ if (x2=="FABCDE") {setverdict(pass);} //variable
+ else {setverdict(fail);}
+// if (x3=="FABCDE") {setverdict(pass);} //value
+// else {setverdict(fail);}
+}
+
+testcase charstrRotateRight2() runs on charstrOper_comptype
+{ var charstring x1,x2,x3;
+ x1:="ABCDEF";
+ x2:=x1 @> 2;
+// x3:="EFABCD" @> 2;
+ if (x2=="EFABCD") {setverdict(pass);} //variable
+ else {setverdict(fail);}
+// if (x3=="EFABCD") {setverdict(pass);} //value
+// else {setverdict(fail);}
+}
+
+testcase charstrRotateRightSum() runs on charstrOper_comptype
+{ var charstring x1,x2,x3;
+ x1:="ABCDEF";
+ x2:=x1 @> (1+1);
+// x3:="EFABCD" @> (1+1);
+ if (x2=="EFABCD") {setverdict(pass);} //variable
+ else {setverdict(fail);}
+// if (x3=="EFABCD") {setverdict(pass);} //value
+// else {setverdict(fail);}
+}
+
+testcase charstrRotateRightEmpty() runs on charstrOper_comptype
+{ var charstring x1,x2,x3;
+ x1:="";
+ x2:=x1 @> 1;
+// x3:="" @> 1;
+ if (x2=="") {setverdict(pass);} //variable
+ else {setverdict(fail);}
+// if (x3=="") {setverdict(pass);} //value
+//(x3=="") {setverdict(pass);} //value
+// else {setverdict(fail);}
+}
+
+testcase charstrRotateLeft1() runs on charstrOper_comptype
+{ var charstring x1,x2,x3;
+ x1:="ABCDEF";
+ x2:=x1 <@ 1;
+// x3:="BCDEFA" <@ 1;
+ if (x2=="BCDEFA") {setverdict(pass);} //variable
+ else {setverdict(fail);}
+// if (x3=="BCDEFA") {setverdict(pass);} //value
+// else {setverdict(fail);}
+}
+
+testcase charstrRotateLeft2() runs on charstrOper_comptype
+{ var charstring x1,x2,x3;
+ x1:="ABCDEF";
+ x2:=x1 <@ 2;
+// x3:="CDEFAB" <@ 2;
+ if (x2=="CDEFAB") {setverdict(pass);} //variable
+ else {setverdict(fail);}
+// if (x3=="CDEFAB") {setverdict(pass);} //value
+// else {setverdict(fail);}
+}
+
+testcase charstrRotateLeftSum() runs on charstrOper_comptype
+{ var charstring x1,x2,x3;
+ x1:="ABCDEF";
+ x2:=x1 <@ (1+1);
+// x3:="CDEFAB" <@ (1+1);
+ if (x2=="CDEFAB") {setverdict(pass);} //variable
+ else {setverdict(fail);}
+// if (x3=="CDEFAB") {setverdict(pass);} //value
+// else {setverdict(fail);}
+}
+
+testcase charstrRotateLeftEmpty() runs on charstrOper_comptype
+{ var charstring x1,x2,x3;
+ x1:="";
+ x2:=x1 <@ 1;
+// x3:="" <@ 1;
+ if (x2=="") {setverdict(pass);} //variable
+ else {setverdict(fail);}
+// if (x3=="") {setverdict(pass);} //value
+// else {setverdict(fail);}
+}
+
+template integer t_mylen1 := 1
+const integer c_mylen1 := 1
+type charstring mycstr1
+type charstring mycstr2 length(4)
+type charstring mycstr3 length(c_mylen1)
+type charstring mycstr4 length(c_mylen1..c_mylen1 + c_mylen1)
+type mycstr4 mycstr5 ("", " ", " ") length (float2int(-0.0) + 1)
+type charstring mycstr6 ("a".."z", "0".."9")
+type charstring mycstr7 ("a".."z") length(1..infinity)
+type mycstr7 mycstr8 length(1)
+type charstring mycstr9 (mycstr2)
+type charstring mycstr10 length(0..infinity) // Full set.
+
+type charstring mycstr11 (pattern "abc?xyz");
+type charstring mycstr12 (pattern @nocase "abc*xyz");
+
+const mycstr7 c_mycstr1 := "a"
+const mycstr9 c_mycstr2 := "abcd"
+
+//template mycstr2 t_mycstr1 := pattern "ab" & "cd"
+//template mycstr9 t_mycstr2 := t_mycstr1
+template mycstr8 t_mycstr3 := "a" length(1)
+template mycstr4 t_mycstr4 := ? length(1..2)
+
+function f_cstr1() return mycstr4 { return " " }
+function f_cstr2() return mycstr3 {
+ return substr(c_mycstr1, 0, 1) & substr("1234567890", 0, 0)
+}
+
+testcase charstrSubtypes() runs on charstrOper_comptype {
+ var template mycstr2 vt_mycstr1 := "abcd" // Length only.
+ var template mycstr4 vt_mycstr2 := "ab" // Length with range.
+ var template mycstr6 vt_mycstr3 := "a" // Value range list.
+ var template mycstr7 vt_mycstr4 := vt_mycstr3 // Value range with length.
+ var template mycstr11 vt_mycstr5 := "abc1xyz"; // Pattern (case sensitive)
+ var template mycstr12 vt_mycstr6 := "abc123xyz"; // Pattern (case insensitive)
+ var mycstr2 v_mycstr1 := valueof(vt_mycstr1)
+ var mycstr4 v_mycstr2 := valueof(vt_mycstr2)
+ var mycstr6 v_mycstr3 := valueof(vt_mycstr3)
+ var mycstr7 v_mycstr4 := valueof(vt_mycstr4)
+ var mycstr11 v_mycstr5 := valueof(vt_mycstr5)
+ var mycstr12 v_mycstr6 := valueof(vt_mycstr6)
+
+ if (valueof(vt_mycstr1) == v_mycstr1 and v_mycstr2 == valueof(vt_mycstr2)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (valueof(vt_mycstr3) == v_mycstr3 and v_mycstr4 == valueof(vt_mycstr4)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (valueof(vt_mycstr5) == v_mycstr5 and v_mycstr6 == valueof(vt_mycstr6)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (c_mycstr1 == f_cstr2() and " " == f_cstr1()) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+testcase charstrIsvalue() runs on charstrOper_comptype{
+ var charstring s0, s1 := "Hello";
+ var template charstring ts_char0 := "ABCD";
+ var template charstring tr_char1 := "AB?D";
+// var template charstring tr_pattern1 := pattern "ABCD";
+// var template charstring tr_patternx := pattern "AB?D";
+ var template charstring tr_opt := omit;
+
+ if ( isvalue(s0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(s1) ) { setverdict(pass); } else { setverdict(fail); };
+
+ if ( isvalue(ts_char0) ) {setverdict(pass); } else { setverdict(fail); }
+ if ( isvalue(tr_char1) ) { setverdict(pass); } else { setverdict(fail); }
+// if ( isvalue(tr_pattern1) ) {setverdict(fail); } else { setverdict(pass); }
+// if ( isvalue(tr_patternx) ) {setverdict(fail); } else { setverdict(pass); }
+ if ( isvalue(tr_opt) ) {setverdict(fail); } else { setverdict(pass); }
+
+ if ( isvalue(modifies ts_char0 := *) ) { setverdict(fail); } else { setverdict(pass); }
+// if ( isvalue(modifies tr_pattern1 := "A?CD") ) { setverdict(pass); } else { setverdict(fail); }
+// if ( isvalue(modifies tr_char1 := pattern "DCBA") ) { setverdict(fail); } else { setverdict(pass); }
+}
+
+testcase charstrIsbound() runs on charstrOper_comptype{
+ var charstring s0, s1 := "Hello";
+ var template charstring ts_char0 := "ABCD";
+ var template charstring tr_char1 := "AB?D";
+// var template charstring tr_pattern1 := pattern "ABCD";
+// var template charstring tr_patternx := pattern "AB?D";
+ var template charstring tr_opt := omit;
+
+ if ( isbound(s0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(s0[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(s1) ) { setverdict(pass); } else { setverdict(fail); };
+
+ if ( isbound(ts_char0) ) {setverdict(pass); } else { setverdict(fail); }
+ if ( isbound(tr_char1) ) { setverdict(pass); } else { setverdict(fail); }
+// if ( isbound(tr_pattern1) ) { setverdict(pass); } else { setverdict(fail); };
+// if ( isbound(tr_patternx) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(tr_opt) ) { setverdict(pass); } else { setverdict(fail); };
+
+ if ( isbound(modifies ts_char0 := *) ) { setverdict(pass); } else { setverdict(fail); };
+// if ( isbound(modifies tr_pattern1 := "A?CD") ) { setverdict(pass); } else { setverdict(fail); }
+// if ( isbound(modifies tr_char1 := pattern "DCBA") ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+testcase tc_simple_charstring_unbound() runs on charstrOper_comptype {
+ var charstring vl_ch1;
+ if(ispresent(vl_ch1)){setverdict(fail)} else {setverdict(pass)}
+ var charstring vl_ch2:="honey";
+ if(ispresent(vl_ch2)) { setverdict(pass)} else {setverdict(fail)}
+ var template charstring vlt_ch3;
+ if(ispresent(vlt_ch3)){setverdict(fail)} else {setverdict(pass)}
+ var template charstring vlt_ch4:="AB?D*"
+ if(ispresent(vlt_ch4)) {setverdict(pass)} else {setverdict(fail)}
+}
+
+//testcase tc_simple_charstring_template_pattern_ispresent() runs on charstrOper_comptype {
+// var template charstring vlt_ch;
+// vlt_ch:= pattern "AB?D"
+// if(ispresent(vlt_ch)) {setverdict(pass)} else {setverdict(fail)}
+//}
+
+testcase tc_simple_charstring() runs on charstrOper_comptype {
+ var charstring vl_ch;
+ if(isbound(vl_ch)){setverdict(fail)} else {setverdict(pass)}
+ vl_ch:="honey"
+ if(isbound(vl_ch)) {setverdict(pass)} else {setverdict(fail)}
+}
+
+testcase tc_simple_charstring_template() runs on charstrOper_comptype {
+ var template charstring vlt_ch;
+ if(isbound(vlt_ch)){setverdict(fail)} else {setverdict(pass)}
+ vlt_ch:="AB?D*"
+ if(isbound(vlt_ch)) {setverdict(pass)} else {setverdict(fail)}
+}
+
+//testcase tc_simple_charstring_template_pattern() runs on charstrOper_comptype {
+// var template charstring vlt_ch;
+// if(isbound(vlt_ch)){setverdict(fail)} else {setverdict(pass)}
+// vlt_ch:= pattern "AB?D"
+// if(isbound(vlt_ch)) {setverdict(pass)} else {setverdict(fail)}
+//}
+
+control {
+ const charstring cl_1:="asd1";
+ var charstring vl_1;
+
+ execute(charstrAssign());
+// execute(charstrAssignQuote());
+ execute(charstrAssignElem());
+ execute(charstrLengthof());
+ execute(charstrAssignElemAdd());
+ execute(charstrConst());
+ execute(charstrCompEq());
+ execute(charstrCompNotEq());
+// execute(charstrCompSmall());
+// execute(charstrCompBig());
+ execute(charstrConcat());
+ execute(charstrRotateRight1());
+ execute(charstrRotateRight2());
+ execute(charstrRotateRightSum());
+ execute(charstrRotateRightEmpty());
+ execute(charstrRotateLeft1());
+ execute(charstrRotateLeft2());
+ execute(charstrRotateLeftSum());
+ execute(charstrRotateLeftEmpty());
+ execute(charstrSubtypes());
+ execute(charstrIsvalue());
+ execute(charstrIsbound());
+ execute(tc_simple_charstring_unbound());
+// execute(tc_simple_charstring_template_pattern_ispresent());
+ execute(tc_simple_charstring());
+ execute(tc_simple_charstring_template());
+// execute(tc_simple_charstring_template_pattern());
+}
+
+}
diff --git a/Regression_Test_java/src/TcontrolTimer.ttcn b/Regression_Test_java/src/TcontrolTimer.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..2c1a4a188929487075ccdc744542d9a7e9d88920
--- /dev/null
+++ b/Regression_Test_java/src/TcontrolTimer.ttcn
@@ -0,0 +1,64 @@
+/******************************************************************************
+ * 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 TcontrolTimer {
+
+type component CT {}
+
+testcase tc_delay(float delay) runs on CT
+{
+ timer T := delay;
+ all timer.stop;
+ T.start;
+ T.timeout;
+ setverdict(pass);
+}
+
+testcase SetVerdict(verdicttype v) runs on CT
+{
+ setverdict(v);
+}
+
+function f()
+{
+ timer T := 0.4;
+ T.start;
+ execute(tc_delay(0.1));
+ alt {
+ [] T.timeout { execute(SetVerdict(fail)); }
+ [] any timer.timeout { execute(SetVerdict(pass)); }
+ }
+}
+
+control {
+ timer T1 := 0.3, T2 := 0.4;
+ T1.start;
+ execute(tc_delay(0.1));
+ T2.start;
+ alt {
+ [] T1.timeout { execute(SetVerdict(pass)); }
+ [] T2.timeout { execute(SetVerdict(fail)); }
+ }
+ all timer.stop;
+ T1.start;
+ execute(tc_delay(0.1), 0.2);
+ T2.start;
+ alt {
+ [] T1.timeout { execute(SetVerdict(pass)); }
+ [] T2.timeout { execute(SetVerdict(fail)); }
+ }
+ all timer.stop;
+ T1.start;
+ f();
+}
+
+}
diff --git a/Regression_Test_java/src/TdefaultOper.ttcn b/Regression_Test_java/src/TdefaultOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..ac18b7a59e28eed28108c05c71072e17867fa8a7
--- /dev/null
+++ b/Regression_Test_java/src/TdefaultOper.ttcn
@@ -0,0 +1,119 @@
+/******************************************************************************
+ * 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
+ * Szabados, Kristof
+ *
+ ******************************************************************************/
+module TdefaultOper
+{
+type component defaultOper_comptype { };
+
+altstep A1() runs on defaultOper_comptype
+{
+ [] any timer.timeout { setverdict(inconc);}
+}
+
+testcase defaultIsvalue() runs on defaultOper_comptype
+{
+ var default v0;
+ var default v1 := null;
+ var template default tdf0;
+ template default tdf1 := null;
+ var default d1 := activate( A1() );
+
+ if ( isvalue(v0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(tdf0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(tdf1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(d1) ) { setverdict(pass); } else { setverdict(fail); };
+
+ tdf0 := d1;
+ d1 := valueof(tdf0);
+}
+
+ altstep as_empty() runs on defaultOper_comptype {
+ [] any timer.timeout { }
+ };
+
+ function f_empty() runs on defaultOper_comptype { }
+
+ testcase tc_special_default_value_unbound() runs on defaultOper_comptype {
+ var default vl_default;
+ if(ispresent(vl_default)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_special_default_value_null() runs on defaultOper_comptype {
+ var default vl_default := null;
+ if(ispresent(vl_default)) {setverdict(pass)} else {setverdict(fail)}
+ }
+ testcase tc_special_default_value_isvalue() runs on defaultOper_comptype {
+ var default vl_default := activate(as_empty());
+ if(ispresent(vl_default)){setverdict(pass)}else {setverdict(fail)};
+
+ deactivate(vl_default);
+ if(ispresent(vl_default)){setverdict(pass)}else {setverdict(fail)};
+ }
+
+ testcase tc_special_compref_unbound() runs on defaultOper_comptype {
+ var defaultOper_comptype vc_myComp;
+ if(ispresent(vc_myComp)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+// testcase tc_special_compref_isvalue() runs on defaultOper_comptype {
+// var defaultOper_comptype vc_myComp:= defaultOper_comptype.create("hali");
+// if(ispresent(vc_myComp)){setverdict(pass)}else {setverdict(fail)};
+//
+// vc_myComp.start(f_empty());
+// if(ispresent(vc_myComp)){setverdict(pass)}else {setverdict(fail)};
+//
+// vc_myComp.done;
+// if(ispresent(vc_myComp)){setverdict(pass)}else {setverdict(fail)};
+// }
+
+testcase tc_special_default_value() runs on defaultOper_comptype {
+ var default vl_default;
+ if(isbound(vl_default)){setverdict(fail)}else {setverdict(pass)};
+
+ vl_default := null;
+ if(isbound(vl_default)) {setverdict(pass)} else {setverdict(fail)}
+
+ vl_default := activate(as_empty());
+ if(isbound(vl_default)){setverdict(pass)}else {setverdict(fail)};
+
+ deactivate(vl_default);
+ if(isbound(vl_default)){setverdict(pass)}else {setverdict(fail)};
+}
+
+//testcase tc_special_compref() runs on defaultOper_comptype {
+// var defaultOper_comptype vc_myComp;
+// if(isbound(vc_myComp)){setverdict(fail)}else {setverdict(pass)};
+//
+// vc_myComp:= defaultOper_comptype.create("hali");
+// if(isbound(vc_myComp)){setverdict(pass)}else {setverdict(fail)};
+//
+// vc_myComp.start(f_empty());
+// if(isbound(vc_myComp)){setverdict(pass)}else {setverdict(fail)};
+//
+// vc_myComp.done;
+// if(isbound(vc_myComp)){setverdict(pass)}else {setverdict(fail)};
+//}
+
+control {
+ execute(defaultIsvalue());
+ execute(tc_special_default_value_unbound());
+ execute(tc_special_default_value_null());
+ execute(tc_special_default_value_isvalue());
+ execute(tc_special_compref_unbound());
+// execute(tc_special_compref_isvalue());
+ execute(tc_special_default_value());
+// execute(tc_special_compref());
+}
+}
diff --git a/Regression_Test_java/src/TenumOper.ttcn b/Regression_Test_java/src/TenumOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..427d9ff42e28eff6e6c7837c831b4c0384f2bc83
--- /dev/null
+++ b/Regression_Test_java/src/TenumOper.ttcn
@@ -0,0 +1,332 @@
+/******************************************************************************
+ * 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
+ * Forstner, Matyas
+ * Kovacs, Ferenc
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TenumOper {
+// ********** Type definitions *********************
+type component emptyComponent {};
+type enumerated myenum1 {xx1,xx2,xx3};
+type enumerated myenum2 {xx3,xx4,xx5}; // reuse identifiers
+type enumerated myenum3 {xx6(2),xx7(4),xx8(1)}; // with numbers
+type enumerated myenum4 {xx9,xx10(3),xx11}; // partly with numbers
+
+type myenum1 myenumSubtype1 (xx1)
+type myenum1 myenumSubtype2
+
+type record myrecord {
+ myenum1 e1 optional,
+ myenum3 e3
+}
+
+type record of myenum4 myrecordof;
+
+// *************** Constanst ***********************
+const myenum1 cg_1:= xx2;
+const myenumSubtype1 cg_mye1 := xx1
+
+template myenum1 t_mye1 := cg_mye1
+template myenum1 t_mye2 := xx1
+template myenumSubtype1 t_mye3 := xx1
+
+modulepar myenumSubtype1 tsp_mod1 := xx1
+
+testcase tc_enumAssign() runs on emptyComponent{
+ var myenum1 vl1:= xx1;
+ var myenum1 vl2;
+ vl2:= xx2;
+ if (vl1==xx1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+ if (vl2==xx2) {setverdict(pass);} //later
+ else {setverdict(fail);}
+}
+
+testcase tc_enumConst() runs on emptyComponent{
+ const myenum1 cl_1:=xx1;
+ if (cg_1==xx2) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+ if (cl_1==xx1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+}
+
+testcase tc_enumCompEq() runs on emptyComponent {
+ var myenum1 vl1,vl2,vl3;
+ var myenum2 vl4;
+ vl1:=xx1;
+ vl2:=xx1;
+ vl3:=xx3;
+ vl4:=xx3;
+ if (vl1==vl2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(vl3==vl2)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (vl1==xx1) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(vl1==xx2)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (xx1==vl1) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(xx3==vl1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+}
+
+testcase tc_enumCompNotEq() runs on emptyComponent
+{ var myenum1 vl1,vl2,vl3;
+ var myenum2 vl4
+ vl1:=xx1;
+ vl2:=xx3;
+ vl3:=xx1;
+ vl4:=xx3;
+ if (vl1!=vl2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(vl1!=vl3)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (vl1!=xx2) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(vl1!=xx1)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (xx2!=vl2) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(xx3!=vl2)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+}
+
+testcase tc_enumCompLess() runs on emptyComponent
+{ var myenum1 vl1,vl2,vl3;
+ vl1:=xx1;
+ vl2:=xx1;
+ vl3:=xx2;
+ if (vl1<vl3) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(vl1<vl2)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(vl3<vl1)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (vl1<xx2) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(vl1<xx1)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(vl3<xx1)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (xx1<vl3) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(xx1<vl2)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(xx2<vl1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+}
+
+testcase tc_enumCompLessEq() runs on emptyComponent
+{ var myenum1 vl1,vl2,vl3;
+ vl1:=xx1;
+ vl2:=xx1;
+ vl3:=xx2;
+ if (vl1<=vl3) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (vl1<=vl2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(vl3<=vl1)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (vl1<=xx2) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (vl1<=xx1) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(vl3<=xx1)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (xx1<=vl3) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (xx1<=vl2) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(xx2<=vl1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+}
+
+testcase tc_enumCompGreat() runs on emptyComponent
+{ var myenum1 vl1,vl2,vl3;
+ vl1:=xx1;
+ vl2:=xx1;
+ vl3:=xx2;
+ if (vl3>vl1) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(vl1>vl2)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(vl1>vl3)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (vl3>xx1) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(vl1>xx1)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(vl2>xx2)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (xx2>vl1) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(xx1>vl2)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(xx1>vl3)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+}
+
+testcase tc_enumCompGreatEq() runs on emptyComponent
+{ var myenum1 vl1,vl2,vl3;
+ vl1:=xx1;
+ vl2:=xx1;
+ vl3:=xx2;
+ if (vl3>=vl1) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (vl1>=vl2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(vl1>=vl3)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (vl3>=xx1) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (vl1>=xx1) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(vl2>=xx2)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (xx2>=vl1) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (xx1>=vl2) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(xx1>=vl3)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+}
+
+// in the number tests the automatic choice of numbers counts.
+testcase tc_enumNumb1() runs on emptyComponent
+{ var myenum1 vl1,vl2,vl3; // automatic numbers
+ vl1:=xx1;
+ vl2:=xx2;
+ vl3:=xx3;
+ if (vl1<vl2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (vl2<vl3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase tc_enumNumb2() runs on emptyComponent
+{ var myenum3 vl1,vl2,vl3; // manual numbers
+ vl1:=xx6; //2
+ vl2:=xx7; //4
+ vl3:=xx8; //1
+ if (vl3<vl1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (vl1<vl2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase tc_enumNumb3() runs on emptyComponent
+{ var myenum4 vl1,vl2,vl3; // semi-automatic numbers
+ vl1:=xx9; //0 - automatic
+ vl2:=xx10; //3 - manual
+ vl3:=xx11; //1 - automatic
+ if (vl1<vl3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (vl3<vl2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+function f_enumReturn() return myenumSubtype1
+{
+ var template myenumSubtype2 vt_mye1 := xx1
+ var myenumSubtype2 vl_mye1 := xx1
+ var myenumSubtype2 vl_myenumSubtype1 := valueof(t_mye1)
+ var myenumSubtype2 vl_myenumSubtype2 := cg_mye1
+ if (cg_mye1 == valueof(vt_mye1)) { return cg_mye1 }
+ else { return valueof(vt_mye1) }
+// if (vl_mye1 == vl_myenumSubtype1 and vl_myenumSubtype1 == vl_myenumSubtype2) { return valueof(t_mye1) }
+// else { return cg_mye1 }
+}
+
+testcase tc_enumSubtypes() runs on emptyComponent
+{
+ if (f_enumReturn() == xx1) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+testcase tc_enumIsvalue() runs on emptyComponent
+{
+ var myenum1 x1 := xx1, x2;
+ template myenum1 subenum := (xx1,xx2);
+ template myenum1 every := ?;
+ template myenum1 actual := xx1;
+
+ if ( isvalue(x1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(x2) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(subenum) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(every) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(actual) ) { setverdict(pass); } else { setverdict(fail); };
+
+ if ( isvalue(myenum1 : ( xx1 )) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(myenum1 : ( xx1, xx2 )) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(myenum1 : *) ) { setverdict(fail); } else { setverdict(pass); };
+
+ if ( isvalue(modifies actual := xx2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(modifies actual := *) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(modifies subenum := xx2) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+testcase tc_int2enum() runs on emptyComponent
+{
+ var myenum1 e1 := xx1;
+ var myenum2 e2;
+ var integer i := 2;
+ var myrecord rec1 := { e1 := omit, e3 := xx7 };
+ var myrecord rec2;
+ var myrecordof recof1 := { xx10, xx11 };
+ var myrecordof recof2 := { xx9 };
+
+ int2enum(1, e1);
+ int2enum(i, e2);
+ int2enum(5 - 3, rec1.e3);
+ int2enum(lengthof(recof1), rec1.e1);
+ int2enum(enum2int(cg_1), rec2.e3);
+ int2enum(1 + str2int("2"), recof1[1]);
+ int2enum(2 / 2, recof2[2]);
+
+ if (e1 != xx2) { setverdict(fail, "e1 = ", e1); }
+ if (e2 != xx5) { setverdict(fail, "e2 = ", e2); }
+ if (rec1 != { e1 := xx3, e3 := xx6 }) { setverdict(fail, "rec1 = ", rec1) };
+ if (log2str(rec2) != "{ e1 := <unbound>, e3 := xx8 (1) }") { setverdict(fail, "rec2 = ", rec2); }
+ if (recof1 != { xx10, xx10 }) { setverdict(fail, "recof1 = ", recof1); }
+ if (log2str(recof2) != "{ xx9 (0), <unbound>, xx11 (1) }") { setverdict(fail, "recof2 = ", recof2); }
+ setverdict(pass);
+}
+
+control {
+ const myenum1 cl_1 := xx1; // can constants be declared in the control part
+ const myenum2 cl_2 := xx3;
+ const myenum3 cl_3 := xx6;
+ const myenum4 cl_4 := xx9;
+ var myenum1 vl_1; // can variable be declared in the control part
+ var myenum2 vl_2;
+ var myenum3 vl_3;
+ var myenum4 vl_4;
+
+ execute(tc_enumAssign());
+ execute(tc_enumConst());
+ execute(tc_enumCompEq());
+ execute(tc_enumCompNotEq());
+ execute(tc_enumCompLess());
+ execute(tc_enumCompLessEq());
+ execute(tc_enumCompGreat());
+ execute(tc_enumCompGreatEq());
+ execute(tc_enumNumb1());
+ execute(tc_enumNumb2());
+ execute(tc_enumNumb3());
+ execute(tc_enumSubtypes());
+ execute(tc_enumIsvalue());
+ execute(tc_int2enum());
+}
+}
diff --git a/Regression_Test_java/src/TfloatOper.ttcn b/Regression_Test_java/src/TfloatOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..e72187dd99395f02247b9a2183b6fc0c0c7d01d2
--- /dev/null
+++ b/Regression_Test_java/src/TfloatOper.ttcn
@@ -0,0 +1,507 @@
+/******************************************************************************
+ * 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
+ * Gecse, Roland
+ * Kovacs, Ferenc
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TfloatOper
+{const float TfloatOper_const1:=2.0;
+type component floatOper_comptype { };
+
+testcase floatAssign() runs on floatOper_comptype
+{ var float x1:=12E3;
+ var float x4:=x1;
+ var float x2,x3;
+ x2:=-124.2;
+ x3:=x2;
+ if (x1==12E3) {setverdict(pass);} //at declaration, value
+ else {setverdict(fail);}
+ if (x4==12000.0) {setverdict(pass);} //at declaration, variable
+ else {setverdict(fail);}
+ if (x2==-124.2) {setverdict(pass);} //later, value
+ else {setverdict(fail);}
+ if (x3==-124.2) {setverdict(pass);} //later, variable
+ else {setverdict(fail);}
+}
+
+testcase floatConst() runs on floatOper_comptype {
+const float TfloatOper_const3:=-5E2;
+if (TfloatOper_const1==2.0) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+//if (TfloatOper_const2==2) {setverdict(pass);} //control part
+// else {setverdict(fail);}
+if (TfloatOper_const3==-500.0) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+}
+
+testcase floatCompEq() runs on floatOper_comptype
+{ var float x1,x2,x3;
+ x1:=100.0;
+ x2:=1E2;
+ x3:=200.0;
+ if (x1==x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x3==x2)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1==1E2) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1==1010.0)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (1E2==x1) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(1001.0==x1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (100.0==1E2) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(1100.0==100.0)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase floatCompNotEq() runs on floatOper_comptype
+{ var float x1,x2,x3;
+ x1:=1E2;
+ x2:=200.0;
+ x3:=100.0;
+ if (x1!=x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x1!=x3)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1!=150.0) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1!=1E2)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (120.0!=x2) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(2E2!=x2)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (111.0!=1E2) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(111.0!=111.0)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase floatCompLess() runs on floatOper_comptype
+{ var float x1,x2,x3;
+ x1:=1E2;
+ x2:=100.0;
+ x3:=200.0;
+ if (x1<x3) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x1<x2)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x3<x1)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1<110.0) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1<1E2)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x2<9E1)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (100.0<x3) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(1E2<x2)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(110.0<x1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (1E2<120.0) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(100.0<1E2)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(110.0<1E1)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase floatCompLessEq() runs on floatOper_comptype
+{ var float x1,x2,x3;
+ x1:=100.0;
+ x2:=1E2;
+ x3:=200.0;
+ if (x1<=x3) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1<=x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x3<=x1)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1<=11E1) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x1<=1E2) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x2<=90.0)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (1E2<=x3) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (100.0<=x2) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(110.0<=x1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (1E2<=120.0) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (100.0<=1E2) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(110.0<=10.0)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase floatCompGreat() runs on floatOper_comptype
+{ var float x1,x2,x3;
+ x1:=100.0;
+ x2:=1E2;
+ x3:=200.0;
+ if (x3>x1) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x1>x2)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x1>x3)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1>99.0) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1>1E2)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x2>11E1)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (210.0>x3) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(1E2>x2)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(90.0>x1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (130.0>1.2E2) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(1E2>100.0)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(10.0>110.0)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase floatCompGreatEq() runs on floatOper_comptype
+{ var float x1,x2,x3;
+ x1:=1E2;
+ x2:=100.0;
+ x3:=200.0;
+ if (x3>=x1) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1>=x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x1>=x3)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1>=99.0) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x1>=1E2) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x2>=11E2)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (210.0>=x3) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (1E2>=x2) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(9E1>=x1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (130.0>=1.2E2) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (100.0>=1E2) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(1E1>=110.0)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase floatAdd() runs on floatOper_comptype
+{ var float x1,x2,x3,x4,x5,x6;
+ x1:=125.5;
+ x2:=1000.0;
+ x3:=x1+x2;
+ x4:=x2+456.2;
+ x5:=1E2+x1;
+ x6:=1E2+234.3;
+ if (x3==1125.5) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x4==1456.2) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x5==225.5) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x6==334.3) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase floatSubs() runs on floatOper_comptype
+{ var float x1,x2,x3,x4,x5,x6;
+ x1:=125.2;
+ x2:=1125.2;
+ x3:=x1-x2;
+ x4:=x2-102.0;
+ x5:=1E2-x1;
+ x6:=100.0-2.34E2;
+ if (((x3+1000.0)<1E-12)and((-1000.0-x3)>-1E-12)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (((x4-1023.2)<1E-12)and((1023.2-x4)>-1E-12)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (((x5+25.2)<1E-12)and((-25.2-x5)>-1E-12)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (((x6+134.0)<1E-12)and((-134.0-x6)>-1E-12)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase floatMultipl() runs on floatOper_comptype
+{ var float x1,x2,x3,x4,x5,x6;
+ x1:=12.0;
+ x2:=10.1;
+ x3:=x1*x2;
+ x4:=x2*-2.0;
+ x5:=1E1*x1;
+ x6:=-2.5*3.0;
+ if (((x3-121.2)<1E-12)and((121.2-x3)>-1E-12)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (((x4+20.2)<1E-12)and((-20.2-x4)>-1E-12)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (((x5-120.0)<1E-12)and((120.0-x5)>-1E-12)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (((x6+7.5)<1E-12)and((-7.5-x6)>-1E-12)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase floatDiv() runs on floatOper_comptype
+{ var float x1,x2,x3,x4,x5,x6;
+ x1:=-125.0;
+ x2:=500.0;
+ x3:=x2/x1;
+ x4:=x2/50.0;
+ x5:=250.0/x1;
+ x6:=1E2/-25.0;
+ if (((x3+4.0)<1E-12)and((-4.0-x3)>-1E-12)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (((x4-10.0)<1E-12)and((10.0-x4)>-1E-12)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (((x5+2.0)<1E-12)and((-2.0-x5)>-1E-12)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (((x6+4.0)<1E-12)and((-4.0-x6)>-1E-12)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+type component floatOperSubtypes_comptype { }
+
+type float myf1
+type float myf2 (1.0, 2.0, 3.0)
+type float myf3 (-infinity..0.0)
+type float myf4 (-infinity..infinity)
+type float myf5 (-infinity..infinity, 0.0, 1.0, 2.0, 3.0)
+type myf5 myf6
+type float myf7 (2147483648.0, 4294967296.0, 8589934592.0)
+type float myf8 (2147483648.0..8589934592.0)
+type float myf9 (myf2, myf3)
+type myf9 myf10 (myf2)
+type myf8 myf11 (2147483648.0..4294967296.0, 4294967296.0..4294967300.0)
+
+const myf1 c_myf1 := 1.0
+const myf2 c_myf2 := 1.0
+const myf3 c_myf3 := 0.0
+const myf4 c_myf4 := c_myf3
+const myf5 c_myf5 := c_myf4
+const myf6 c_myf6 := c_myf5
+const myf7 c_myf7 := 4294967296.0
+const myf8 c_myf8 := c_myf7
+const myf9 c_myf9 := 0.0
+const myf10 c_myf10 := 1.0
+template myf1 t_myf1 := 1.0
+template myf2 t_myf2 := 1.0
+template myf3 t_myf3 := 0.0
+template myf4 t_myf4 := t_myf3
+template myf5 t_myf5 := t_myf4
+template myf6 t_myf6 := t_myf5
+template myf7 t_myf7 := 4294967296.0
+template myf8 t_myf8 := t_myf7
+template myf9 t_myf9 := 0.0
+template myf10 t_myf10 := 1.0
+
+testcase floatSubtypes() runs on floatOperSubtypes_comptype
+{
+ if (c_myf1 == c_myf2 and valueof(t_myf1) == valueof(t_myf2)) { setverdict(pass) }
+ else { setverdict(fail) }
+ var template myf1 vt_myf1 := 1.0
+ var template myf2 vt_myf2 := 1.0
+ var myf1 v_myf1 := 1.0
+ var myf2 v_myf2 := 1.0
+ if (v_myf1 == v_myf2 and valueof(vt_myf1) == valueof(vt_myf2)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (c_myf3 == c_myf4 and c_myf4 == c_myf5 and c_myf5 == c_myf6 and
+ valueof(t_myf3) == valueof(t_myf4) and valueof(t_myf4) == valueof(t_myf5) and
+ valueof(t_myf5) == valueof(t_myf6)) { setverdict(pass) }
+ else { setverdict(fail) }
+ var template myf3 vt_myf3 := 0.0
+ var template myf4 vt_myf4 := vt_myf3
+ var template myf5 vt_myf5 := vt_myf4
+ var template myf6 vt_myf6 := vt_myf5
+ var myf3 v_myf3 := 0.0
+ var myf4 v_myf4 := v_myf3
+ var myf5 v_myf5 := v_myf4
+ var myf6 v_myf6 := v_myf5
+ if (v_myf3 == v_myf4 and v_myf4 == v_myf5 and v_myf5 == v_myf6 and
+ valueof(vt_myf3) == valueof(vt_myf4) and valueof(vt_myf4) == valueof(vt_myf5) and
+ valueof(vt_myf5) == valueof(vt_myf6)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (c_myf7 == c_myf8 and valueof(t_myf7) == valueof(t_myf8)) { setverdict(pass) }
+ else { setverdict(fail) }
+ var template myf7 vt_myf7 := 4294967296.0
+ var template myf8 vt_myf8 := vt_myf7
+ var myf7 v_myf7 := 4294967296.0
+ var myf8 v_myf8 := v_myf7
+ if (v_myf7 == v_myf8 and valueof(vt_myf7) == valueof(vt_myf8)) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+testcase floatIsvalue() runs on floatOper_comptype {
+ var float f0, f1 := 1.0;
+ var template float tf0;
+ var template float tf1 := (5.5);
+ var template float tf2 := (1.0 .. 2.0);
+
+ if ( isvalue(f0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(f1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(tf0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(tf1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(tf2) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(f1 + 1.0) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+testcase floatIsbound() runs on floatOper_comptype {
+ var float f0, f1 := 1.0;
+ var template float tf0;
+ var template float tf1 := (5.5);
+ var template float tf2 := (1.0 .. 2.0);
+
+ if ( isbound(f0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(f1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(tf0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(tf1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(tf2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(f1 + 1.0) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+testcase floatComparison() runs on floatOper_comptype {
+ //
+ var float minus_zero := -0.0;
+ var float plus_zero := 0.0;
+
+ //----------------
+
+ if (minus_zero == -0.0) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT == -0.0") }
+ if (minus_zero <= 0.0) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT <= 0.0") }
+ if (minus_zero < 0.0) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT < 0.0") }
+ if (minus_zero <= plus_zero) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT <= 0.0") }
+ if (minus_zero < plus_zero) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT < 0.0") }
+ if (plus_zero >= minus_zero) { setverdict(pass); } else { setverdict(fail, __LINE__, ": 0.0 NOT >= -0.0") }
+ if (plus_zero > minus_zero) { setverdict(pass); } else { setverdict(fail, __LINE__, ": 0.0 NOT > -0.0") }
+
+ if (-infinity < minus_zero ) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity NOT < -0.0") }
+ if (-infinity <= minus_zero ) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity NOT <= -0.0") }
+ if (minus_zero < infinity) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT < infinity") }
+ if (minus_zero <= infinity) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT <= infinity") }
+ if (minus_zero < not_a_number) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT < not_a_number") }
+ if (minus_zero <= not_a_number) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT <= not_a_number") }
+ if (not_a_number > minus_zero) { setverdict(pass); } else { setverdict(fail, __LINE__, ": not_a_number NOT > -0.0") }
+ if (not_a_number >= minus_zero) { setverdict(pass); } else { setverdict(fail, __LINE__, ": not_a_number NOT >= -0.0") }
+
+ //----------------
+
+ var float plus_inf := infinity;
+ if (plus_inf == infinity) { setverdict(pass); } else { setverdict(fail, __LINE__, ": infinity==infinity:NotOK") }
+ if (-infinity < plus_inf ) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity<infinity:NotOK") }
+ if (-infinity <= plus_inf ) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity<=infinity:NotOK") }
+ if (plus_inf < not_a_number) { setverdict(pass); } else { setverdict(fail, __LINE__, ": infinity<not_a_number:NotOK") }
+ if (plus_inf <= not_a_number) { setverdict(pass); } else { setverdict(fail, __LINE__, ": infinity<=not_a_number:NotOK") }
+
+ //----------------
+
+ var float minus_inf := -infinity;
+ if (minus_inf == -infinity) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity==-infinity:NotOK") }
+ if (minus_inf < not_a_number) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity<not_a_number:NotOK") }
+ if (minus_inf <= not_a_number) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity<=not_a_number:NotOK") }
+
+ //----------------
+
+ var float NaN := not_a_number;
+ if (NaN != not_a_number) { setverdict(fail, __LINE__, ": not_a_number==not_a_number:NotOK") }
+ if (NaN < NaN) { setverdict(fail, __LINE__, ": not_a_number<not_a_number:NotOK") }
+ if (NaN > NaN) { setverdict(fail, __LINE__, ": not_a_number<not_a_number:NotOK") }
+}
+
+testcase constFloatComparison() runs on floatOper_comptype {
+ //
+ const float minus_zero := -0.0;
+ const float plus_zero := 0.0;
+
+ //----------------
+
+ if (minus_zero == -0.0) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT == -0.0") }
+ if (minus_zero <= 0.0) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT <= 0.0") }
+ if (minus_zero < 0.0) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT < 0.0") }
+ if (minus_zero <= plus_zero) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT <= 0.0") }
+ if (minus_zero < plus_zero) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT < 0.0") }
+ if (plus_zero >= minus_zero) { setverdict(pass); } else { setverdict(fail, __LINE__, ": 0.0 NOT >= -0.0") }
+ if (plus_zero > minus_zero) { setverdict(pass); } else { setverdict(fail, __LINE__, ": 0.0 NOT > -0.0") }
+
+ if (-infinity < minus_zero ) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity NOT < -0.0") }
+ if (-infinity <= minus_zero ) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity NOT <= -0.0") }
+ if (minus_zero < infinity) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT < infinity") }
+ if (minus_zero <= infinity) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT <= infinity") }
+ if (minus_zero < not_a_number) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT < not_a_number") }
+ if (minus_zero <= not_a_number) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -0.0 NOT <= not_a_number") }
+ if (not_a_number > minus_zero) { setverdict(pass); } else { setverdict(fail, __LINE__, ": not_a_number NOT > -0.0") }
+ if (not_a_number >= minus_zero) { setverdict(pass); } else { setverdict(fail, __LINE__, ": not_a_number NOT >= -0.0") }
+
+ //----------------
+
+ const float plus_inf := infinity;
+ if (plus_inf == infinity) { setverdict(pass); } else { setverdict(fail, __LINE__, ": infinity==infinity:NotOK") }
+ if (-infinity < plus_inf ) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity<infinity:NotOK") }
+ if (-infinity <= plus_inf ) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity<=infinity:NotOK") }
+ if (plus_inf < not_a_number) { setverdict(pass); } else { setverdict(fail, __LINE__, ": infinity<not_a_number:NotOK") }
+ if (plus_inf <= not_a_number) { setverdict(pass); } else { setverdict(fail, __LINE__, ": infinity<=not_a_number:NotOK") }
+
+ //----------------
+
+ const float minus_inf := -infinity;
+ if (minus_inf == -infinity) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity==-infinity:NotOK") }
+ if (minus_inf < not_a_number) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity<not_a_number:NotOK") }
+ if (minus_inf <= not_a_number) { setverdict(pass); } else { setverdict(fail, __LINE__, ": -infinity<=not_a_number:NotOK") }
+
+ //----------------
+
+ const float NaN := not_a_number;
+ if (NaN != not_a_number) { setverdict(fail, __LINE__, ": not_a_number==not_a_number:NotOK") }
+ if (NaN < NaN) { setverdict(fail, __LINE__, ": not_a_number<not_a_number:NotOK") }
+ if (NaN > NaN) { setverdict(fail, __LINE__, ": not_a_number<not_a_number:NotOK") }
+}
+
+control {
+ const float cl_1:=2.0;
+ var float vl_1;
+
+ execute(floatAssign());
+ execute(floatConst());
+ execute(floatCompEq());
+ execute(floatCompNotEq());
+ execute(floatCompLess());
+ execute(floatCompLessEq());
+ execute(floatCompGreat());
+ execute(floatCompGreatEq());
+ execute(floatAdd());
+ execute(floatSubs());
+ execute(floatMultipl());
+ execute(floatDiv());
+ execute(floatSubtypes());
+ execute(floatIsvalue());
+ execute(floatIsbound());
+ execute(floatComparison());
+ execute(constFloatComparison());
+}
+
+}
diff --git a/Regression_Test_java/src/TfloatOperSpecial.ttcn b/Regression_Test_java/src/TfloatOperSpecial.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..d7c988a8badef5c30c031e7f0ee9d74aeea48097
--- /dev/null
+++ b/Regression_Test_java/src/TfloatOperSpecial.ttcn
@@ -0,0 +1,601 @@
+/******************************************************************************
+ * 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:
+ * Szabo, Bence Janos
+ *
+ ******************************************************************************/
+module TfloatOperSpecial {
+
+type component EmptyCT {}
+
+
+testcase tc_addition() runs on EmptyCT {
+
+ var float f := infinity;
+ var float f2 := 1.0;
+ f := f + 1.0;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+ f := f + f2;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+
+ f := -infinity;
+ f := f + 1.0;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+ f := f + f2;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+
+ f := f2 + f;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+
+ f := infinity + 1.0;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+
+ f := -infinity + 1.0;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+
+ f := not_a_number + f2;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := f2 + not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := infinity + not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := -infinity + not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := -infinity + infinity;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := infinity + infinity;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+ f := -infinity + -infinity;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+ f := not_a_number + not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ setverdict(pass);
+}
+
+testcase tc_subtraction() runs on EmptyCT {
+
+ var float f := infinity;
+ var float f2 := 1.0;
+ f := f - 1.0;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+ f := f - f2;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+
+ f := f2 - f;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+
+ f := -infinity;
+ f := f - 1.0;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+ f := f - f2;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+
+ f := infinity - 1.0;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+
+ f := -infinity - 1.0;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+
+
+ f := not_a_number - f2;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := f2 - not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := infinity - not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := -infinity - not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := -infinity - infinity;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+
+ f := infinity - infinity;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := -infinity - -infinity;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+ f := not_a_number - not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ setverdict(pass);
+}
+
+
+testcase tc_multiplication() runs on EmptyCT {
+ var float f := infinity;
+ var float f2 := 2.0;
+ var float f3 := -2.0;
+ f := f * 2.0;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+ f := f * f2;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+ f := f * f3;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+
+ f := infinity;
+ f := f2 * f;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+
+ f := -infinity;
+ f := f * 2.0;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+ f := f * f2;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+ f := f * f3;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+
+ f := infinity * 1.0;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+
+ f := -infinity * 1.0;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+
+ f := not_a_number * f2;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := f2 * not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := infinity * not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := -infinity * not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := -infinity * infinity;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+
+ f := infinity * infinity;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+
+ f := -infinity * -infinity;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+ f := not_a_number * not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ setverdict(pass);
+}
+
+
+testcase tc_division() runs on EmptyCT {
+ var float f := infinity;
+ var float f2 := 2.0;
+ var float f3 := -2.0;
+ f := f / 2.0;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+ f := f / f2;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+ f := f / f3;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+
+ f := infinity;
+ f := f2 / f;
+ if (f != 0.000000) {
+ setverdict(fail);
+ }
+
+ f := -infinity;
+ f := f / 2.0;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+ f := f / f2;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+ f := f / f3;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+
+ f := f2 / f;
+ if (f != 0.000000) {
+ setverdict(fail);
+ }
+
+ f := infinity;
+ f := f3 / f;
+ if (f != -0.000000) {
+ setverdict(fail);
+ }
+
+ f := -infinity;
+ f := f2 / f;
+ if (f != -0.000000) {
+ setverdict(fail);
+ }
+
+ f := -infinity;
+ f := f3 / f;
+ if (f != 0.000000) {
+ setverdict(fail);
+ }
+
+ f := infinity / 2.0;
+ if (f != infinity) {
+ setverdict(fail);
+ }
+
+ f := -infinity / 2.0;
+ if (f != -infinity) {
+ setverdict(fail);
+ }
+
+
+ f := not_a_number / f2;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := f2 / not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := infinity / not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := -infinity / not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := -infinity / infinity;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := infinity / infinity;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ f := -infinity / -infinity;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+ f := not_a_number / not_a_number;
+ if (f != not_a_number) {
+ setverdict(fail);
+ }
+
+ setverdict(pass);
+}
+
+
+//===========================================================================//
+
+
+const float inf := infinity;
+const float neginf := -infinity;
+const float two := 2.0;
+const float negtwo := -2.0;
+
+// All of theese are infinity
+const float c_f1 := inf + two;
+const float c_f2 := inf + negtwo;
+const float c_f3 := inf - two;
+const float c_f4 := inf - negtwo;
+const float c_f5 := inf * two;
+const float c_f6 := inf / two;
+const float c_f7 := neginf * negtwo;
+const float c_f8 := neginf / negtwo;
+const float c_f21 := inf + inf;
+const float c_f22 := inf * inf;
+const float c_f23 := -inf * -inf;
+
+// All of theese are -infinity
+const float c_f9 := neginf + two;
+const float c_f10 := neginf + negtwo;
+const float c_f11 := neginf - two;
+const float c_f12 := neginf - negtwo;
+const float c_f13 := neginf * two;
+const float c_f14 := neginf / two;
+const float c_f15 := inf * negtwo;
+const float c_f16 := inf / negtwo;
+const float c_f24 := -inf - inf;
+const float c_f25 := -inf * inf;
+const float c_f26 := inf * -inf;
+const float c_f27 := -inf + -inf;
+
+
+// All of theese are 0.000000
+const float c_f17 := two / inf;
+
+// All of theese are -0.000000
+const float c_f18 := two / neginf;
+
+// All of theese are not_a_number
+const float c_f19 := inf * 0.0;
+const float c_f20 := neginf * 0.0;
+const float c_f28 := not_a_number + 1.0;
+const float c_f29 := not_a_number - 1.0;
+const float c_f30 := 1.0 + not_a_number;
+const float c_f31 := 1.0 - not_a_number;
+const float c_f32 := not_a_number * 1.0;
+const float c_f33 := not_a_number / 1.0;
+const float c_f34 := 1.0 * not_a_number;
+const float c_f35 := 1.0 / not_a_number;
+const float c_f36 := inf / inf;
+const float c_f37 := -inf / inf;
+const float c_f38 := -inf / -inf;
+const float c_f39 := inf / -inf;
+const float c_f40 := not_a_number + not_a_number;
+const float c_f41 := not_a_number - not_a_number;
+const float c_f42 := not_a_number * not_a_number;
+const float c_f43 := not_a_number / not_a_number;
+
+testcase tc_compile_time() runs on EmptyCT {
+
+ // Infinities
+ if (c_f1 != infinity) {
+ setverdict(fail);
+ }
+ if (c_f2 != infinity) {
+ setverdict(fail);
+ }
+ if (c_f3 != infinity) {
+ setverdict(fail);
+ }
+ if (c_f4 != infinity) {
+ setverdict(fail);
+ }
+ if (c_f5 != infinity) {
+ setverdict(fail);
+ }
+ if (c_f6 != infinity) {
+ setverdict(fail);
+ }
+ if (c_f7 != infinity) {
+ setverdict(fail);
+ }
+ if (c_f8 != infinity) {
+ setverdict(fail);
+ }
+ if (c_f21 != infinity) {
+ setverdict(fail);
+ }
+ if (c_f22 != infinity) {
+ setverdict(fail);
+ }
+ if (c_f23 != infinity) {
+ setverdict(fail);
+ }
+
+
+ // Negative infinities
+ if (c_f9 != -infinity) {
+ setverdict(fail);
+ }
+ if (c_f10 != -infinity) {
+ setverdict(fail);
+ }
+ if (c_f11 != -infinity) {
+ setverdict(fail);
+ }
+ if (c_f12 != -infinity) {
+ setverdict(fail);
+ }
+ if (c_f13 != -infinity) {
+ setverdict(fail);
+ }
+ if (c_f14 != -infinity) {
+ setverdict(fail);
+ }
+ if (c_f15 != -infinity) {
+ setverdict(fail);
+ }
+ if (c_f16 != -infinity) {
+ setverdict(fail);
+ }
+ if (c_f24 != -infinity) {
+ setverdict(fail);
+ }
+ if (c_f25 != -infinity) {
+ setverdict(fail);
+ }
+ if (c_f26 != -infinity) {
+ setverdict(fail);
+ }
+ if (c_f27 != -infinity) {
+ setverdict(fail);
+ }
+
+
+ // 0.000000
+ if (c_f17 != 0.000000) {
+ setverdict(fail);
+ }
+
+ // -0.000000
+ if (c_f18 != -0.000000) {
+ setverdict(fail);
+ }
+
+
+ // Not a number
+ if (c_f19 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f20 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f28 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f29 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f30 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f31 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f32 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f33 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f34 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f35 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f36 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f37 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f38 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f39 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f40 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f41 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f42 != not_a_number) {
+ setverdict(fail);
+ }
+ if (c_f43 != not_a_number) {
+ setverdict(fail);
+ }
+
+ setverdict(pass);
+}
+
+//===========================================================================//
+
+control {
+ execute(tc_addition());
+ execute(tc_subtraction());
+ execute(tc_multiplication());
+ execute(tc_division());
+ execute(tc_compile_time());
+}
+
+}
\ No newline at end of file
diff --git a/Regression_Test_java/src/ThexstrOper.ttcn b/Regression_Test_java/src/ThexstrOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..34296ae6f133174f0d1f0cc50c37a43374424331
--- /dev/null
+++ b/Regression_Test_java/src/ThexstrOper.ttcn
@@ -0,0 +1,102 @@
+/******************************************************************************
+ * 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
+ * Szabados, Kristof
+ *
+ ******************************************************************************/
+module ThexstrOper
+{
+type component hexstrOper_comptype { }
+
+type hexstring myhstr0
+type hexstring myhstr1 length(1)
+type hexstring myhstr2 length(0..1)
+type hexstring myhstr3 ('0'H, '1'H, '00'H, '01'H, '10'H, '11'H) length(1)
+type hexstring myhstr4 ('0'H, '1'H)
+type hexstring myhstr5 (int2hex(0, 1) & ''H, int2hex(1, 1))
+type myhstr5 myhstr6
+type myhstr6 myhstr7 (c_myhstr1, int2hex(hex2int(c_myhstr1), 1))
+type myhstr6 myhstr8 (int2hex(hex2int('0'H), 1))
+type hexstring myhstr9 (myhstr2, myhstr3)
+type hexstring myhstr10 length(0..infinity) // Full set.
+
+const hexstring c_myhstr1 := '0'H
+const myhstr9 c_myhstr2 := c_myhstr1
+
+template hexstring t_myhstr1 := '0'H
+template myhstr9 t_myhstr2 := t_myhstr1
+template myhstr3 t_myhstr3 := '0'H length(1)
+// TITAN doesn't allow patterns to be other than `charstring' or `universal
+// charstring' types. It's denied by the grammar.
+
+function f_hstr1() return myhstr6 {
+ return substr(replace(int2hex(0, 1) & int2hex(1, 1), 0, 1, '1'H), 0, 1)
+}
+
+testcase hexstrSubtypes() runs on hexstrOper_comptype {
+ var template myhstr1 vt_myhstr1 := '0'H // Simple length.
+ var template myhstr2 vt_myhstr2 := ''H // Length with range.
+ var template myhstr3 vt_myhstr3 := vt_myhstr1 // Values and length.
+ var template myhstr4 vt_myhstr4 := vt_myhstr1 // Values only.
+ var myhstr1 v_myhstr1 := '0'H
+ var myhstr2 v_myhstr2 := ''H
+ var myhstr3 v_myhstr3 := v_myhstr1
+ var myhstr4 v_myhstr4 := v_myhstr1
+
+ if (valueof(vt_myhstr1) == v_myhstr1 and v_myhstr2 == valueof(vt_myhstr2)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (valueof(vt_myhstr3) == v_myhstr3 and v_myhstr4 == valueof(vt_myhstr4)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (f_hstr1() == '1'H) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+testcase hexstrIsvalue() runs on hexstrOper_comptype{
+ var hexstring hstr0;
+ var hexstring hstr1 := '1111'H;
+ var template hexstring thstr;
+
+ if ( isvalue(hstr0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(hstr1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(thstr) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+testcase hexstrIsbound() runs on hexstrOper_comptype {
+ var hexstring hstr0;
+ var hexstring hstr1 := '1111'H;
+ var template hexstring thstr;
+
+ if ( isbound(hstr0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(hstr0[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(hstr1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(thstr) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+testcase CR_TR00018474() runs on hexstrOper_comptype {
+ // Indexing of string template variables.
+ var template hexstring vth1 := 'AABBCCDDEE'H
+ var template hexstring vth2 := 'AABB?CC'H // It's a pattern, cannot be indexed.
+ vth1[0] := 'B'H
+ if (match('BABBCCDDEE'H, vth1)) { setverdict(pass) } else { setverdict(fail) }
+ vth1[0] := 'B'H // Indexed assignment notation cannot be used here.
+ vth1[1] := 'A'H // Still works, nothing special.
+ if (match('BABBCCDDEE'H, vth1)) { setverdict(pass) } else { setverdict(fail) }
+}
+
+control {
+ const hexstring cl_1 := '0'H
+ var hexstring vl_1;
+
+ execute(hexstrSubtypes());
+ execute(hexstrIsvalue());
+ execute(hexstrIsbound());
+ execute(CR_TR00018474());
+}
+}
diff --git a/Regression_Test_java/src/TintOper.ttcn b/Regression_Test_java/src/TintOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..c6f59fa53cb45fda9b18daa7743da3512a4840e0
--- /dev/null
+++ b/Regression_Test_java/src/TintOper.ttcn
@@ -0,0 +1,1079 @@
+/******************************************************************************
+ * 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
+ * Forstner, Matyas
+ * Kovacs, Ferenc
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TintOper
+{const integer TintOper_const1:=2;
+type component intOper_comptype { };
+/*
+type port PCOType message
+{
+ inout integer
+ inout eint1
+ inout rint1
+}
+
+type component bigIntOper_comptype { port PCOType comp_port }
+*/
+
+template integer tint1 := -12345678910111213141516
+template integer tint2 := 123456789101112131415
+template integer tint3 := -11111111111111111111111
+template integer tint4 := 111111111111111111111
+type enumerated eint1 {ec1(-1), ec2(2147483647), ec3(-2147483647)}
+type record rint1 {
+ integer f1,
+ integer f2,
+ integer f3,
+ integer f4
+}
+
+template integer t_param1(rint1 par) := par.f2; // parameterised template
+
+modulepar integer par_unbound;
+modulepar integer par_bound := 42;
+
+testcase intAssign() runs on intOper_comptype
+{ var integer x1:=123;
+ var integer x4:=x1;
+ var integer x2,x3;
+ x2:=124;
+ x3:=x2;
+ if (x1==123) {setverdict(pass);} //at declaration, value
+ else {setverdict(fail);}
+ if (x4==123) {setverdict(pass);} //at declaration, variable
+ else {setverdict(fail);}
+ if (x2==124) {setverdict(pass);} //later, value
+ else {setverdict(fail);}
+ if (x3==124) {setverdict(pass);} //later, variable
+ else {setverdict(fail);}
+}
+
+testcase intConst() runs on intOper_comptype {
+const integer TintOper_const3:=5;
+if (TintOper_const1==2) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+//if (TintOper_const2==2) {setverdict(pass);} //control part
+// else {setverdict(fail);}
+if (TintOper_const3==5) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+}
+
+testcase intCompEq() runs on intOper_comptype
+{ var integer x1,x2,x3;
+ x1:=100;
+ x2:=100;
+ x3:=200;
+ if (x1==x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x3==x2)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1==100) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1==1010)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (100==x1) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(1001==x1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (100==100) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(1100==100)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase intCompNotEq() runs on intOper_comptype
+{ var integer x1,x2,x3;
+ x1:=100;
+ x2:=200;
+ x3:=100;
+ if (x1!=x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x1!=x3)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1!=150) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1!=100)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (120!=x2) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(200!=x2)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (111!=112) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(111!=111)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase intCompLess() runs on intOper_comptype
+{ var integer x1,x2,x3;
+ x1:=100;
+ x2:=100;
+ x3:=200;
+ if (x1<x3) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x1<x2)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x3<x1)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1<110) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1<100)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x2<90)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (100<x3) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(100<x2)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(110<x1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (100<120) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(100<100)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(110<10)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase intCompLessEq() runs on intOper_comptype
+{ var integer x1,x2,x3;
+ x1:=100;
+ x2:=100;
+ x3:=200;
+ if (x1<=x3) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1<=x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x3<=x1)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1<=110) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x1<=100) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x2<=90)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (100<=x3) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (100<=x2) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(110<=x1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (100<=120) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (100<=100) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(110<=10)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase intCompGreat() runs on intOper_comptype
+{ var integer x1,x2,x3;
+ x1:=100;
+ x2:=100;
+ x3:=200;
+ if (x3>x1) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x1>x2)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x1>x3)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1>99) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1>100)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x2>110)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (210>x3) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(100>x2)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(90>x1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (130>120) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(100>100)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(10>110)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase intCompGreatEq() runs on intOper_comptype
+{ var integer x1,x2,x3;
+ x1:=100;
+ x2:=100;
+ x3:=200;
+ if (x3>=x1) {setverdict(pass);} //variable_variable
+ else {setverdict(fail, "1");}
+ if (x1>=x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail, "2");}
+ if (not(x1>=x3)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail, "3");}
+ if (x1>=99) {setverdict(pass);} //variable_value
+ else {setverdict(fail, "4");}
+ if (x1>=100) {setverdict(pass);} //variable_value
+ else {setverdict(fail, "5");}
+ if (not(x2>=110)) {setverdict(pass);} //variable_value
+ else {setverdict(fail, "6");}
+ if (210>=x3) {setverdict(pass);} //value_variable
+ else {setverdict(fail, "7");}
+ if (100>=x2) {setverdict(pass);} //value_variable
+ else {setverdict(fail, "8");}
+ if (not(90>=x1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail, "9");}
+ if (130>=120) {setverdict(pass);} //value_value
+ else {setverdict(fail, "10");}
+ if (100>=100) {setverdict(pass);} //value_value
+ else {setverdict(fail, "11");}
+ if (not(10>=110)) {setverdict(pass);} //value_value
+ else {setverdict(fail, "12");}
+}
+
+testcase intAdd() runs on intOper_comptype
+{ var integer x1,x2,x3,x4,x5,x6,x7,x8,x9;
+ const integer x10:=-100,x11:=-200,x12:=x10+x11;
+ x1:=125;
+ x2:=1000;
+ x3:=x1+x2;
+ x4:=x2+456;
+ x5:=100+x1;
+ x6:=100+234;
+ x7:=-100;
+ x8:=-200;
+ x9:=x7+x8;
+ if (x3==1125) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x4==1456) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x5==225) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x6==334) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (x9==-300) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x7+x8==-300) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (-100+-200==-300) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x12==-300) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x10+x11==x12) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (-100+-200==x12) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase intSubs() runs on intOper_comptype
+{ var integer x1,x2,x3,x4,x5,x6;
+ x1:=125;
+ x2:=1125;
+ x3:=x1-x2;
+ x4:=x2-102;
+ x5:=100-x1;
+ x6:=100-234;
+ if (x3==-1000) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x4==1023) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x5==-25) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x6==-134) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase intMultipl() runs on intOper_comptype
+{ var integer x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17;
+ x1:=12;
+ x2:=10;
+ x3:=x1*x2;
+ x4:=x2*-2;
+ x5:=10*x1;
+ x6:=-2*3;
+ x7:=3*-2;
+ x8:=-2*-3;
+ x9:=-x1*x2;
+ x10:=-x1*-x2;
+ x11:=x1*-x2;
+ x12:=1000000;
+ x13:=x12*x2;
+ x14:=-x2*x12;
+ x15:=-x12*-x2;
+ x16:=1000000*10;
+ x17:=-10*1000000;
+ if (x3==120) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x4==-20) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x5==120) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x6==-6) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (x7==-6) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x8==6) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x9==-120) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x10==120) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x11==-120) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x13==10000000) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x14==-10000000) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x15==10000000) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x16==10000000) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x17==-10000000) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase intDiv() runs on intOper_comptype
+{ var integer x1,x2,x3,x4,x5,x6,x7,x8;
+ x1:=-125;
+ x2:=501;
+ x3:=x2/x1;
+ x4:=x2/50;
+ x5:=252/x1;
+ x6:=102/-25;
+ x7:=-102/-25;
+ x8:=-25/102;
+ if (x3==-4) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x4==10) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x5==-2) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x6==-4) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (x7==4) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x8==0) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase intMod() runs on intOper_comptype
+{ var integer x1,x2,x3,x4,x5,x6;
+ x1:=-125;
+ x2:=503;
+ x3:=x2 mod x1;
+ x4:=x2 mod 50;
+ x5:=254 mod x1;
+ x6:=102 mod -25; // positive x
+ if (x3==3) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x4==3) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x5==4) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x6==2) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ x2:=-503;
+ x3:=x2 mod x1;
+ x4:=x2 mod 50;
+ x5:=-254 mod x1;
+ x6:=-102 mod -25; // negative x
+ if (x3==122) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x4==47) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x5==121) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x6==23) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase intRem() runs on intOper_comptype
+{ var integer x1,x2,x3,x4,x5,x6;
+ x1:=-125;
+ x2:=503;
+ x3:=x2 rem x1;
+ x4:=x2 rem 50;
+ x5:=254 rem x1;
+ x6:=102 rem -25; // positive x
+ if (x3==3) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x4==3) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x5==4) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x6==2) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ x2:=-503;
+ x3:=x2 rem x1;
+ x4:=x2 rem 50;
+ x5:=-254 rem x1;
+ x6:=-102 rem -25; // negative x
+ if (x3==-3) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x4==-3) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (x5==-4) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (x6==-2) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+/*
+testcase intShiftRight1() runs on intOper_comptype
+{ var integer x1,x2;
+ x1:=234;
+ x2:=x1 >> 1;
+ if (x2==117) {setverdict(pass);} //variable
+ else {setverdict(fail);}
+}
+
+testcase intShiftRight2() runs on intOper_comptype
+{ var integer x1,x2;
+ x1:=234;
+ x2:=x1 >> 2;
+ if (x2==58) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase intShiftRightSum() runs on intOper_comptype
+{ var integer x1,x2;
+ x1:=234;
+ x2:=x1 >> (1+1);
+ if (x2==58) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase intShiftLeft1() runs on intOper_comptype
+{ var integer x1,x2;
+ x1:=112;
+ x2:=x1 << 1;
+ if (x2==224) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase intShiftLeft2() runs on intOper_comptype
+{ var integer x1,x2;
+ x1:=112;
+ x2:=x1 << 2;
+ if (x2==448) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase intShiftLeftSum() runs on intOper_comptype
+{ var integer x1,x2;
+ x1:=112;
+ x2:=x1 << (1+1);
+ if (x2==448) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+*/
+/*
+testcase bigIntConst() runs on bigIntOper_comptype
+{
+ connect(self:comp_port, self:comp_port)
+ timer T := 1.0
+ comp_port.send(-12345678910111213141516)
+ comp_port.send(123456789101112131415)
+ comp_port.send(-1234567891011121314)
+ comp_port.send(12345678910111213)
+ T.start
+ alt {
+ [11111111111111111111 > 0] comp_port.receive(-12345678910111213141516) { setverdict(pass) repeat }
+ [22222222222222222222 > 11111111111111111111] comp_port.receive(123456789101112131415) { setverdict(pass) repeat }
+ [33333333333333333333 > 22222222222222222222] comp_port.receive(-1234567891011121314) { setverdict(pass) repeat }
+ [44444444444444444444 > 33333333333333333333] comp_port.receive(12345678910111213) { setverdict(pass) }
+ [] T.timeout { setverdict(fail) }
+ }
+ disconnect(self:comp_port, self:comp_port)
+}
+
+testcase bigIntVar() runs on bigIntOper_comptype
+{
+ connect(self:comp_port, self:comp_port)
+ timer T := 1.0
+ const integer ca := 0
+ const integer cb := 11111111111111111111
+ const integer cc := 22222222222222222222
+ const integer cd := 33333333333333333333
+ const integer ce := 44444444444444444444
+ var integer a := -12345678910111213141516
+ var integer b := 123456789101112131415
+ var integer c := -1234567891011121314
+ var integer d := 123456789101112131
+ comp_port.send(a)
+ comp_port.send(b)
+ comp_port.send(c)
+ comp_port.send(d)
+ T.start
+ alt {
+ [cb > ca] comp_port.receive(a) { setverdict(pass) repeat }
+ [cc > cb] comp_port.receive(b) { setverdict(pass) repeat }
+ [cd > cc] comp_port.receive(c) { setverdict(pass) repeat }
+ [ce > cd] comp_port.receive(d) { setverdict(pass) }
+ [] T.timeout { setverdict(fail) }
+ }
+ disconnect(self:comp_port, self:comp_port)
+}
+
+testcase bigIntTemplate() runs on bigIntOper_comptype
+{
+ connect(self:comp_port, self:comp_port)
+ timer T := 1.0
+ var integer a := -12345678910111213141516
+ var integer b := 123456789101112131415
+ var integer c := -11111111111111111111111
+ var integer d := 111111111111111111111
+ // No `valueof' on large integer templates. Only values can be sent on
+ // ports due to interface problems.
+ comp_port.send(a)
+ comp_port.send(b)
+ comp_port.send(c)
+ comp_port.send(d)
+ T.start
+ alt {
+ [] comp_port.receive(tint1) { setverdict(pass) repeat }
+ [] comp_port.receive(tint2) { setverdict(pass) repeat }
+ [] comp_port.receive(tint3) { setverdict(pass) repeat }
+ [] comp_port.receive(tint4) { setverdict(pass) }
+ [] T.timeout { setverdict(fail) }
+ }
+ disconnect(self:comp_port, self:comp_port)
+}
+
+testcase bigIntVariableTemplate() runs on bigIntOper_comptype
+{
+ connect(self:comp_port, self:comp_port)
+ timer T := 1.0
+ var integer a := -12345678910111213141516
+ var integer b := 123456789101112131415
+ var integer c := -11111111111111111111111
+ var integer d := 111111111111111111111
+ var template integer vtint1 := a
+ var template integer vtint2 := b
+ var template integer vtint3 := -11111111111111111111111
+ var template integer vtint4 := 111111111111111111111
+ comp_port.send(a)
+ comp_port.send(b)
+ comp_port.send(c)
+ comp_port.send(d)
+ T.start
+ alt {
+ [] comp_port.receive(vtint1) { setverdict(pass) repeat }
+ [] comp_port.receive(vtint2) { setverdict(pass) repeat }
+ [] comp_port.receive(vtint3) { setverdict(pass) repeat }
+ [] comp_port.receive(vtint4) { setverdict(pass) }
+ [] T.timeout { setverdict(fail) }
+ }
+ disconnect(self:comp_port, self:comp_port)
+}
+
+testcase bigIntEnumerated() runs on bigIntOper_comptype
+{
+ connect(self:comp_port, self:comp_port)
+ timer T := 1.0
+ var eint1 veint1 := ec1
+ var eint1 veint2 := ec2
+ var eint1 veint3 := ec3
+ comp_port.send(veint1); T.start; comp_port.receive(veint1) { setverdict(pass) }; T.stop
+ comp_port.send(veint2); T.start; comp_port.receive(veint2) { setverdict(pass) }; T.stop
+ comp_port.send(veint3); T.start; comp_port.receive(veint3) { setverdict(pass) }; T.stop
+ disconnect(self:comp_port, self:comp_port)
+}
+
+testcase bigIntRecord() runs on bigIntOper_comptype
+{
+ connect(self:comp_port, self:comp_port)
+ timer T := 1.0
+ var rint1 vrint1 := { 12345678910111213141516, -11111111111111111111, 1234, -12345 }
+ var rint1 vrint2 := { 128, 65536, 4294967296, -4294967296 }
+ var rint1 vrint3 := { 2147483648, -2147483648, 0, -1 }
+ var rint1 vrint4 := { 4294967296, -4294967296, 4294967295, -4294967295 }
+ var rint1 vrint5 := { 4294967297, -4294967297, 2147483648, -2147483648 }
+ var rint1 vrint6 := { 2147483647, -2147483647, 2147483649, -2147483649 }
+ var rint1 vrint7 := { 260217910, -260217910, 1, -1 }
+ comp_port.send(vrint1); T.start; comp_port.receive(vrint1) { setverdict(pass) }; T.stop
+ comp_port.send(vrint2); T.start; comp_port.receive(vrint2) { setverdict(pass) }; T.stop
+ comp_port.send(vrint3); T.start; comp_port.receive(vrint3) { setverdict(pass) }; T.stop
+ comp_port.send(vrint4); T.start; comp_port.receive(vrint4) { setverdict(pass) }; T.stop
+ comp_port.send(vrint5); T.start; comp_port.receive(vrint5) { setverdict(pass) }; T.stop
+ comp_port.send(vrint6); T.start; comp_port.receive(vrint6) { setverdict(pass) }; T.stop
+ comp_port.send(vrint7); T.start; comp_port.receive(vrint7) { setverdict(pass) }; T.stop
+ disconnect(self:comp_port, self:comp_port)
+}*/
+
+testcase bigIntLogicalOps() runs on intOper_comptype
+{
+ {
+ // Only Cond2/Cond4/Cond6/Cond7/Cond10/Cond11/Cond15/Cond17/Cond18 should
+ // stay. Test for conditional operators and CP on big integers.
+ if (12345678910111213141516 < 0) { setverdict(fail) } // Removed by CP.
+ if (12345678910111213141516 > 0) { setverdict(pass) }
+ if (12345678910111213141516 == 0) { setverdict(fail) } // Removed by CP.
+ if (12345678910111213141516 != 0) { setverdict(pass) }
+ if (12345678910111213141516 <= 0) { setverdict(fail) } // Removed by CP.
+ if (12345678910111213141516 >= 0) { setverdict(pass) }
+ if (0 < 12345678910111213141516) { setverdict(pass) }
+ if (0 > 12345678910111213141516) { setverdict(fail) } // Removed by CP.
+ if (0 == 12345678910111213141516) { setverdict(fail) } // Removed by CP.
+ if (0 != 12345678910111213141516) { setverdict(pass) }
+ if (0 <= 12345678910111213141516) { setverdict(pass) }
+ if (0 >= 12345678910111213141516) { setverdict(fail) } // Removed by CP.
+ if (12345678910111213141516 < 12345678910111213141516) { setverdict(fail) } // Removed by CP.
+ if (12345678910111213141516 > 12345678910111213141516) { setverdict(fail) } // Removed by CP.
+ if (12345678910111213141516 == 12345678910111213141516) { setverdict(pass) }
+ if (12345678910111213141516 != 12345678910111213141516) { setverdict(fail) } // Removed by CP.
+ if (12345678910111213141516 <= 12345678910111213141516) { setverdict(pass) }
+ if (12345678910111213141516 >= 12345678910111213141516) { setverdict(pass) }
+ }
+ {
+ // With a constant. Same as the previous.
+ const integer i := 0, j := 12345678910111213141516
+ if (j < i) { setverdict(fail) } // Removed by CP.
+ if (j > i) { setverdict(pass) }
+ if (j == i) { setverdict(fail) } // Removed by CP.
+ if (j != i) { setverdict(pass) }
+ if (j <= i) { setverdict(fail) } // Removed by CP.
+ if (j >= i) { setverdict(pass) }
+ if (i < j) { setverdict(pass) }
+ if (i > j) { setverdict(fail) } // Removed by CP.
+ if (i == j) { setverdict(fail) } // Removed by CP.
+ if (i != j) { setverdict(pass) }
+ if (i <= j) { setverdict(pass) }
+ if (i >= j) { setverdict(fail) } // Removed by CP.
+ if (j < j) { setverdict(fail) } // Removed by CP.
+ if (j > j) { setverdict(fail) } // Removed by CP.
+ if (j == j) { setverdict(pass) }
+ if (j != j) { setverdict(fail) } // Removed by CP.
+ if (j <= j) { setverdict(pass) }
+ if (j >= j) { setverdict(pass) }
+ }
+ {
+ // With variable operands. No CP.
+ var integer i := 0, j := 12345678910111213141516, result := 0
+ if (12345678910111213141516 < i) { result := result + 1 }
+ if (12345678910111213141516 > i) { result := result + 1 }
+ if (12345678910111213141516 == i) { result := result + 1 }
+ if (12345678910111213141516 != i) { result := result + 1 }
+ if (12345678910111213141516 <= i) { result := result + 1 }
+ if (12345678910111213141516 >= i) { result := result + 1 }
+ if (i < 12345678910111213141516) { result := result + 1 }
+ if (i > 12345678910111213141516) { result := result + 1 }
+ if (i == 12345678910111213141516) { result := result + 1 }
+ if (i != 12345678910111213141516) { result := result + 1 }
+ if (i <= 12345678910111213141516) { result := result + 1 }
+ if (i >= 12345678910111213141516) { result := result + 1 }
+ if (12345678910111213141516 < j) { result := result + 1 }
+ if (j > 12345678910111213141516) { result := result + 1 }
+ if (12345678910111213141516 == j) { result := result + 1 }
+ if (j != 12345678910111213141516) { result := result + 1 }
+ if (12345678910111213141516 <= j) { result := result + 1 }
+ if (j >= 12345678910111213141516) { result := result + 1 }
+ if (result == 9) { setverdict(pass) } // Number of branches executed.
+ else { setverdict(fail) }
+ }
+}
+
+testcase bigIntBasicArithmetic() runs on intOper_comptype
+{
+ {
+ // Basic tests for add/subtract/multiply/divide/mod/rem. Constant literals
+ // at first. These are all handled by CP.
+ if (100000000000000000000 + 100000000000000000000 == 200000000000000000000) { setverdict(pass) } else { setverdict(fail, "1") }
+ if (100000000000000000000 + 0 == 100000000000000000000) { setverdict(pass) } else { setverdict(fail, "2") }
+ if (0 + 100000000000000000000 == 100000000000000000000) { setverdict(pass) } else { setverdict(fail, "3") }
+ if (100000000000000000000 - 100000000000000000000 == 0) { setverdict(pass) } else { setverdict(fail, "4") }
+ if (100000000000000000000 - 0 == 100000000000000000000) { setverdict(pass) } else { setverdict(fail, "5") }
+ if (0 - 100000000000000000000 == -100000000000000000000) { setverdict(pass) } else { setverdict(fail, "6") }
+ if (100000000000000000000 * 100000000000000000000 == 10000000000000000000000000000000000000000) { setverdict(pass) } else { setverdict(fail, "7") }
+ if (-100000000000000000000 * 100000000000000000000 == -10000000000000000000000000000000000000000) { setverdict(pass) } else { setverdict(fail, "7") }
+ if (-100000000000000000000 * -100000000000000000000 == 10000000000000000000000000000000000000000) { setverdict(pass) } else { setverdict(fail, "") }
+ if (100000000000000000000 * 0 == 0) { setverdict(pass) } else { setverdict(fail) }
+ if (0 * 100000000000000000000 == 0) { setverdict(pass) } else { setverdict(fail) }
+ if (100000000000000000000 / 100000000000000000000 == 1) { setverdict(pass) } else { setverdict(fail) }
+ if (0 / 100000000000000000000 == 0) { setverdict(pass) } else { setverdict(fail) }
+ if (100000000000000000000 mod 100000000000000000000 == 0) { setverdict(pass) } else { setverdict(fail) } // Same as rem.
+ if (0 mod 100000000000000000000 == 0) { setverdict(pass) } else { setverdict(fail) }
+ if (100000000000000000000 rem 100000000000000000000 == 0) { setverdict(pass) } else { setverdict(fail) }
+ if (0 rem 100000000000000000000 == 0) { setverdict(pass) } else { setverdict(fail) }
+ }
+ {
+ // Same as before with constants.
+ const integer i := 0, j := 100000000000000000000, k := 1
+ if (j + j == 200000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (j + i == j) { setverdict(pass) } else { setverdict(fail) }
+ if (i + j == j) { setverdict(pass) } else { setverdict(fail) }
+ if (j - j == i) { setverdict(pass) } else { setverdict(fail) }
+ if (j - i == j) { setverdict(pass) } else { setverdict(fail) }
+ if (i - j == -j) { setverdict(pass) } else { setverdict(fail) }
+ if (j * j == 10000000000000000000000000000000000000000) { setverdict(pass) } else { setverdict(fail) } // Ugly.
+ if (j * i == i) { setverdict(pass) } else { setverdict(fail) }
+ if (i * j == i) { setverdict(pass) } else { setverdict(fail) }
+ if (k * j == j) { setverdict(pass) } else { setverdict(fail) }
+ if (k * -j == -j) { setverdict(pass) } else { setverdict(fail) }
+ if (-k * j == -j) { setverdict(pass) } else { setverdict(fail) }
+ if (-k * -j == j) { setverdict(pass) } else { setverdict(fail) }
+ if (j / j == 1) { setverdict(pass) } else { setverdict(fail) }
+ if (i / j == i) { setverdict(pass) } else { setverdict(fail) }
+ if (j mod j == i) { setverdict(pass) } else { setverdict(fail) } // Same as rem.
+ if (i mod j == i) { setverdict(pass) } else { setverdict(fail) }
+ if (j rem j == i) { setverdict(pass) } else { setverdict(fail) }
+ if (i rem j == i) { setverdict(pass) } else { setverdict(fail) }
+ }
+ {
+ // With variables and constants mixed. No CP.
+ var integer i := 0, j := 100000000000000000000, k := 1
+ if (100000000000000000000 + j == 200000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (j + i == 100000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (i + 100000000000000000000 == j) { setverdict(pass) } else { setverdict(fail) }
+ if (100000000000000000000 - j == 0) { setverdict(pass) } else { setverdict(fail) }
+ if (j - i == 100000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (i - 100000000000000000000 == -j) { setverdict(pass) } else { setverdict(fail) }
+ if (100000000000000000000 * j == 10000000000000000000000000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (100000000000000000000 * -j == -10000000000000000000000000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (-100000000000000000000 * j == -10000000000000000000000000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (j * 100000000000000000000 == 10000000000000000000000000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (-j * 100000000000000000000 == -10000000000000000000000000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (j * -100000000000000000000 == -10000000000000000000000000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (i * 100000000000000000000 == 0) { setverdict(pass) } else { setverdict(fail) }
+ if (j / 100000000000000000000 == k) { setverdict(pass) } else { setverdict(fail) }
+ if (i / 100000000000000000000 == 0) { setverdict(pass) } else { setverdict(fail) }
+ if (j mod 100000000000000000000 == i) { setverdict(pass) } else { setverdict(fail) } // Same as rem.
+ if (i mod 100000000000000000001 == 0) { setverdict(pass) } else { setverdict(fail) }
+ if (100000000000000000000 rem j == i) { setverdict(pass) } else { setverdict(fail) }
+ if (i rem 100000000000000000000 == 0) { setverdict(pass) } else { setverdict(fail) }
+ }
+ {
+ var integer i := 4294967295, j := -4294967295, k := 2147483647, l := -2147483647
+ if ((i + i) / 4294967295 == 2) { setverdict(pass) } else { setverdict(fail) }
+ if ((j + j) / -4294967295 == 2) { setverdict(pass) } else { setverdict(fail) }
+ if ((k + k) / 2147483647 == 2) { setverdict(pass) } else { setverdict(fail) }
+ if ((l + l) / -2147483647 == 2) { setverdict(pass) } else { setverdict(fail) }
+ }
+ {
+ var integer i := -100000000000000000000, j := -100000000000000000000, k := i + j
+ const integer l := -100000000000000000000, m := -100000000000000000000, o := l + m
+ if (i + j == -200000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (k == -200000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (-100000000000000000000 + -100000000000000000000 == k) { setverdict(pass) } else { setverdict(fail) }
+ if (-100000000000000000000 + -100000000000000000000 == o) { setverdict(pass) } else { setverdict(fail) }
+ if (-100000000000000000000 + -100000000000000000000 == -200000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (l + m == -200000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ if (o == -200000000000000000000) { setverdict(pass) } else { setverdict(fail) }
+ }
+}
+
+//template rint1 myrint1 := { f1 := 260217910, f2 := 1234567891011121314151617181920, f3 := 0, f4 := -260217910 }
+//template rint1 myrint2 := { f1 := 2147483648, f2 := -2147483648, f3 := 0, f4 := -1 }
+//template rint1 myrint3 := { 4294967296, -4294967296, 4294967295, -4294967295 }
+//template rint1 myrint4 := { 4294967297, -4294967297, 2147483648, -2147483648 }
+/*
+testcase bigIntTemplateSendRecv() runs on bigIntOper_comptype
+{
+ // Implicit `valueof' on sending with implicit matching.
+ connect(self:comp_port, self:comp_port)
+ timer T := 1.0
+ comp_port.send(myrint1); T.start; comp_port.receive(myrint1) { setverdict(pass) }; T.stop
+ comp_port.send(myrint2); T.start; comp_port.receive(myrint2) { setverdict(pass) }; T.stop
+ comp_port.send(myrint3); T.start; comp_port.receive(myrint3) { setverdict(pass) }; T.stop
+ comp_port.send(myrint4); T.start; comp_port.receive(myrint4) { setverdict(pass) }; T.stop
+ disconnect(self:comp_port, self:comp_port)
+}*/
+
+// For testing operator-() in compile-time/run-time on boundaries.
+testcase bigIntOnTheEdge() runs on intOper_comptype
+{
+ const integer LLONG_MIN := -9223372036854775808
+ const integer LLONG_MAX := 9223372036854775807
+ const integer INT_MIN := -2147483648
+ const integer INT_MAX := 2147483647
+ var integer llong_min_v := LLONG_MIN
+ var integer llong_max_v := LLONG_MAX
+ var integer int_min_v := INT_MIN
+ var integer int_max_v := INT_MAX
+ // Compile-time.
+ if (-LLONG_MIN == 9223372036854775808) { setverdict(pass) } else { setverdict(fail, "1") }
+ if (-LLONG_MAX == -9223372036854775807) { setverdict(pass) } else { setverdict(fail, "2") }
+ if (-LLONG_MIN == LLONG_MAX + 1) { setverdict(pass) } else { setverdict(fail, "3") }
+ if (-LLONG_MAX == LLONG_MIN + 1) { setverdict(pass) } else { setverdict(fail, "4") }
+ if (-INT_MIN == 2147483648) { setverdict(pass) } else { setverdict(fail, "5") }
+ if (-INT_MAX == -2147483647) { setverdict(pass) } else { setverdict(fail, "6") }
+ if (-INT_MIN == INT_MAX + 1) { setverdict(pass) } else { setverdict(fail, "7") }
+ if (-INT_MAX == INT_MIN + 1) { setverdict(pass) } else { setverdict(fail, "8") }
+ if (9223372036854775808 - 1 == LLONG_MAX) { setverdict(pass) } else { setverdict(fail, "9") }
+ if (-LLONG_MIN - 1 == LLONG_MAX) { setverdict(pass) } else { setverdict(fail, "10") }
+ // Run-time.
+ if (-llong_min_v == 9223372036854775808) { setverdict(pass) } else { setverdict(fail, "11") }
+ if (-llong_max_v == -9223372036854775807) { setverdict(pass) } else { setverdict(fail, "12") }
+ if (-llong_min_v == llong_max_v + 1) { setverdict(pass) } else { setverdict(fail, "13") }
+ if (-llong_max_v == llong_min_v + 1) { setverdict(pass) } else { setverdict(fail, "14") }
+ if (-int_min_v == 2147483648) { setverdict(pass) } else { setverdict(fail, "15") }
+ if (-int_max_v == -2147483647) { setverdict(pass) } else { setverdict(fail, "16") }
+ if (-int_min_v == int_max_v + 1) { setverdict(pass) } else { setverdict(fail, "17") }
+ if (-int_max_v == int_min_v + 1) { setverdict(pass) } else { setverdict(fail, "18") }
+ if (2147483648 - 1 == int_max_v) { setverdict(pass) } else { setverdict(fail, "19") }
+ if (-int_min_v - 1 == int_max_v) { setverdict(pass) } else { setverdict(fail, "20") }
+}
+
+//external function MyConverter() return boolean
+//
+//testcase bigIntLongLong() runs on intOper_comptype
+//{
+// if (MyConverter()) { setverdict(pass) } else { setverdict(fail) }
+//}
+
+type component intOperSubtypes_comptype { }
+
+type integer myi1
+type integer myi2 (1, 2, 3)
+type integer myi3 (-infinity..0)
+type integer myi4 (-infinity..infinity)
+type integer myi5 (-infinity..infinity, 0, 1, 2, 3)
+type myi5 myi6
+type integer myi7 (2147483648, 4294967296, 8589934592)
+type integer myi8 (2147483648..8589934592)
+type integer myi9 (1, 2..c_myi1 + 3)
+type integer myi10 (1, str2int(log2str(valueof(t_myi1))) + 1, 3)
+type integer myi11 (-1, -0, 1)
+type integer myi12 (myi2, myi3)
+type myi12 myi13 (myi2)
+type myi4 myi14 (0..infinity)
+
+const myi1 c_myi1 := 1
+const myi2 c_myi2 := 1
+const myi3 c_myi3 := 0
+const myi4 c_myi4 := c_myi3
+const myi5 c_myi5 := c_myi4
+const myi6 c_myi6 := c_myi5
+const myi7 c_myi7 := 4294967296
+const myi8 c_myi8 := c_myi7
+const myi9 c_myi9 := 4
+const myi10 c_myi10 := c_myi1
+const myi12 c_myi11 := 0
+const myi13 c_myi12 := 1
+template myi1 t_myi1 := 1
+template myi2 t_myi2 := 1
+template myi3 t_myi3 := 0
+template myi4 t_myi4 := t_myi3
+template myi5 t_myi5 := t_myi4
+template myi6 t_myi6 := t_myi5
+template myi7 t_myi7 := 4294967296
+template myi8 t_myi8 := t_myi7
+template myi12 t_myi9 := 0
+template myi13 t_myi10 := 1
+
+function f_i1() return boolean {
+ var myi9 v_myi1 := 4
+ var myi10 v_myi2 := v_myi1
+ var template myi9 vt_myi1 := 4
+ var template myi10 vt_myi2 := vt_myi1
+ if (v_myi1 == valueof(vt_myi1) and valueof(vt_myi1) == c_myi1 and
+ v_myi2 == valueof(vt_myi2) and valueof(vt_myi2) == c_myi2) { return true }
+ else { return false }
+}
+
+testcase intSubtypes() runs on intOperSubtypes_comptype
+{
+ if (c_myi1 == c_myi2 and valueof(t_myi1) == valueof(t_myi2)) { setverdict(pass) }
+ else { setverdict(fail) }
+ var template myi1 vt_myi1 := 1
+ var template myi2 vt_myi2 := 1
+ var myi1 v_myi1 := 1
+ var myi2 v_myi2 := 1
+ if (v_myi1 == v_myi2 and valueof(vt_myi1) == valueof(vt_myi2)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (c_myi3 == c_myi4 and c_myi4 == c_myi5 and c_myi5 == c_myi6 and
+ valueof(t_myi3) == valueof(t_myi4) and valueof(t_myi4) == valueof(t_myi5) and
+ valueof(t_myi5) == valueof(t_myi6)) { setverdict(pass) }
+ else { setverdict(fail) }
+ var template myi3 vt_myi3 := 0
+ var template myi4 vt_myi4 := vt_myi3
+ var template myi5 vt_myi5 := vt_myi4
+ var template myi6 vt_myi6 := vt_myi5
+ var myi3 v_myi3 := 0
+ var myi4 v_myi4 := v_myi3
+ var myi5 v_myi5 := v_myi4
+ var myi6 v_myi6 := v_myi5
+ if (v_myi3 == v_myi4 and v_myi4 == v_myi5 and v_myi5 == v_myi6 and
+ valueof(vt_myi3) == valueof(vt_myi4) and valueof(vt_myi4) == valueof(vt_myi5) and
+ valueof(vt_myi5) == valueof(vt_myi6)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (c_myi7 == c_myi8 and valueof(t_myi7) == valueof(t_myi8)) { setverdict(pass) }
+ else { setverdict(fail) }
+ var template myi7 vt_myi7 := 4294967296
+ var template myi8 vt_myi8 := vt_myi7
+ var myi7 v_myi7 := 4294967296
+ var myi8 v_myi8 := v_myi7
+ if (v_myi7 == v_myi8 and valueof(vt_myi7) == valueof(vt_myi8)) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+testcase intIsvalue() runs on intOper_comptype
+{
+ var integer i0, i1 := 1;
+ var template integer one_int := (13);
+ var template integer two_ints := (1,2);
+
+ if ( isvalue(i0) ) { setverdict(fail, "1"); } else { setverdict(pass); };
+ if ( isvalue(i1) ) { setverdict(pass); } else { setverdict(fail, "2"); };
+ if ( isvalue(TintOper_const1) ) { setverdict(pass); } else { setverdict(fail, "3"); };
+ if ( isvalue(one_int) ) { setverdict(pass); } else { setverdict(fail, "4"); };
+ if ( isvalue(two_ints) ) { setverdict(fail, "5"); } else { setverdict(pass); };
+
+ if ( isvalue(par_unbound) ) { setverdict(fail, "6"); } else { setverdict(pass); };
+ if ( isvalue(par_bound) ) { setverdict(pass); } else { setverdict(fail, "7"); };
+
+ if ( isvalue(i1 + 1) ) { setverdict(pass); } else { setverdict(fail, "8"); };
+}
+
+testcase intIsbound() runs on intOper_comptype
+{
+ var integer i0, i1 := 1;
+ var template integer one_int := (13);
+ var template integer two_ints := (1,2);
+
+ if ( isbound(i0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(i1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(TintOper_const1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(one_int) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(two_ints) ) { setverdict(pass); } else { setverdict(fail); };
+
+ if ( isbound(par_unbound) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(par_bound) ) { setverdict(pass); } else { setverdict(fail); };
+
+ if ( isbound(i1 + 1) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+testcase HO29687() runs on intOper_comptype {
+ log(log2str(integer:1));
+ setverdict(pass);
+}
+
+testcase HO29695() runs on intOper_comptype {
+ log(valueof(integer:1));
+ setverdict(pass);
+}
+
+testcase tc_simple_integer() runs on intOper_comptype {
+ var integer vl_i;
+ if(isbound(vl_i)){setverdict(fail)} else {setverdict(pass)}
+ vl_i:=5;
+ if(isbound(vl_i)) {setverdict(pass)} else {setverdict(fail)}
+
+ var template integer vtl_i :=*;
+ if(isbound( vtl_i )) {setverdict(pass)}else {setverdict(fail)};
+ vtl_i:=5;
+ if(isbound( vtl_i )) {setverdict(pass)}else {setverdict(fail)};
+}
+
+template integer t_i(integer i, integer j) :=i+j;
+
+testcase tc_runtimeExprEval() runs on intOper_comptype {
+ var template integer vt_i:= t_i(1,2);
+ var integer vl_i:=1, vl_j:=0;
+ if(isbound(vt_i)) {setverdict(pass)} else {setverdict(fail)};
+ if(isbound(t_i(1,2))) {setverdict(pass)} else {setverdict(fail)};
+ if(isbound(t_i(1,2*vl_i))) {setverdict(pass)} else {setverdict(fail)};
+ //if(isbound(t_i(1,2/vl_j))) {setverdict(pass)} else {setverdict(fail)}; //DTE
+}
+
+ testcase tc_simple_integer_unbound() runs on intOper_comptype {
+ var integer vl_i;
+ if(ispresent(vl_i)){setverdict(fail)} else {setverdict(pass)} //fail
+ }
+
+ testcase tc_simple_integer_value() runs on intOper_comptype {
+ var integer vl_i:=5;
+ if(ispresent(vl_i)) {setverdict(pass)} else {setverdict(fail)} //pass,
+ }
+
+ testcase tc_simple_integer_templ_asterix() runs on intOper_comptype {
+ var template integer vtl_i :=*;
+ if(ispresent( vtl_i )) {setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_simple_integer_templ_qm() runs on intOper_comptype {
+ var template integer vtl_i :=?;
+ if(ispresent( vtl_i )) {setverdict(pass)}else {setverdict(fail)};
+ }
+
+ testcase tc_simple_integer_templ_value() runs on intOper_comptype {
+ var template integer vtl_i:=5;
+ if(ispresent( vtl_i )) {setverdict(pass)}else {setverdict(fail)};
+ }
+
+ testcase tc_runtimeExprEval_ispresent() runs on intOper_comptype {
+ var template integer vt_i:= t_i(1,2);
+ var integer vl_i:=1, vl_j:=0;
+ if(ispresent(vt_i)) {setverdict(pass)} else {setverdict(fail)};
+ if(ispresent(t_i(1,2))) {setverdict(pass)} else {setverdict(fail)};
+ if(ispresent(t_i(1,2*vl_i))) {setverdict(pass)} else {setverdict(fail)};
+ //if(ispresent(t_i(1,2/vl_j))) {setverdict(pass)} else {setverdict(fail)}; //DTE
+ }
+
+control {
+ log("executing TintOper");
+ const integer cl_1:=2;
+ var integer vl_1;
+
+ execute(intAssign());
+ execute(intConst());
+ execute(intCompEq());
+ execute(intCompNotEq());
+ execute(intCompLess());
+ execute(intCompLessEq());
+ execute(intCompGreat());
+ execute(intCompGreatEq());
+ execute(intAdd());
+ execute(intSubs());
+ execute(intMultipl());
+ execute(intDiv());
+ execute(intMod());
+ execute(intRem());
+ execute(intSubtypes());
+ /*
+ execute(intShiftRight1());
+ execute(intShiftRight2());
+ execute(intShiftRightSum());
+ execute(intShiftLeft1());
+ execute(intShiftLeft2());
+ execute(intShiftLeftSum());
+ */
+ /*execute(bigIntConst());
+ execute(bigIntVar());
+ execute(bigIntTemplate());
+ execute(bigIntVariableTemplate());
+ execute(bigIntEnumerated());
+ execute(bigIntRecord());*/
+ execute(bigIntLogicalOps());
+ execute(bigIntBasicArithmetic());
+ //execute(bigIntTemplateSendRecv());
+ execute(bigIntOnTheEdge());
+ //execute(bigIntLongLong());
+
+ execute(intIsvalue());
+ execute(intIsbound());
+
+ execute(HO29687());
+ execute(HO29695());
+
+ execute(tc_simple_integer());
+ execute(tc_runtimeExprEval());
+ execute(tc_simple_integer_unbound());
+ execute(tc_simple_integer_value());
+ execute(tc_simple_integer_templ_asterix());
+ execute(tc_simple_integer_templ_qm());
+ execute(tc_simple_integer_templ_value());
+ execute(tc_runtimeExprEval_ispresent());
+}
+
+}
diff --git a/Regression_Test_java/src/TlostTimer.ttcn b/Regression_Test_java/src/TlostTimer.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..ce14815b4b965777b42b00126fe48994725c4755
--- /dev/null
+++ b/Regression_Test_java/src/TlostTimer.ttcn
@@ -0,0 +1,52 @@
+/******************************************************************************
+ * 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
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TlostTimer {
+
+type component CT {
+ timer T1 := 1.0, T2 := 2.0;
+}
+
+testcase tc1() runs on CT
+{
+ T1.start;
+ T2.start;
+ T2.timeout;
+ if (T1.read != 0.0) { setverdict(fail); }
+ if (T1.running) { setverdict(fail); }
+ alt {
+ [] any timer.timeout { setverdict(pass); }
+ [else] { setverdict(fail); }
+ }
+}
+
+testcase tc2() runs on CT
+{
+ T1.start;
+ T2.start;
+ T2.timeout;
+ if (T1.running) { setverdict(fail); }
+ all timer.stop;
+ alt {
+ [] T1.timeout { setverdict(fail); }
+ [] any timer.timeout { setverdict(fail); }
+ [else] { setverdict(pass); }
+ }
+}
+
+control {
+ execute(tc1());
+ execute(tc2());
+}
+
+}
diff --git a/Regression_Test_java/src/TobjidOper.ttcn b/Regression_Test_java/src/TobjidOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..d313a4f51483e8362428ac3c3b2eb29c65813beb
--- /dev/null
+++ b/Regression_Test_java/src/TobjidOper.ttcn
@@ -0,0 +1,266 @@
+/******************************************************************************
+ * 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
+ * Szabados, Kristof
+ *
+ ******************************************************************************/
+module TobjidOper {
+
+type component objidOper_comptype { }
+
+//external function enco(in objid oi) return octetstring
+//with { extension "prototype(convert) encode(BER:BER_ENCODE_DER)" }
+//
+//external function deco(in octetstring oi) return objid
+//with { extension "prototype(convert) decode(BER:BER_ACCEPT_ALL)" }
+
+type objid typedefbasic_myobjid;
+type objid MyObjids0 (objid{itu_t(0) identified_organization(4) etsi(0)})
+type objid MyObjids1 (objid{itu_t identified_organization etsi(0)})
+type objid MyObjids2 (objid{0 4 0})
+const integer c_etsi := 0
+template integer t_etsi := 0
+const objid itu_idOrg := objid{itu_t identified_organization}
+const objid c_etsiMobNet := objid{itu_t identified_organization etsi(0) mobile_domain(0) umts_Network(1)}
+const objid c_etsiNet := objid{itu_t identified_organization etsi(0) inDomain(1) in_Network(1)}
+type objid MyObjids3 (objid{itu_idOrg c_etsi})
+type objid MyObjids4 (objid{0 4 0 0}, objid{0 4 0 1})
+type MyObjids4 MyObjids5
+template MyObjids4 t_myobjids1 := objid{0 4 0 0}
+// These should be allowed as well:
+// type MyObjids MyNarrowerObjids (objid{0 4 0 0 1 0}, objid{0 4 1 1}, objid{0 4 1 3})
+// type objid MyObjidRange (objid{0 4 0 0}..objid{0 4 0 5})
+// But concatenation of object identifier doesn't seem to work at all...
+
+// Lots of '1' bits
+const objid c_bits := objid {
+ 0
+
+ 1
+ 3
+ 7
+ 15
+ 31
+ 63
+ 127
+ 255
+
+ 511
+ 1023
+ 2047
+ 4095
+ 8191
+ 16383
+ 32767
+ 65535
+
+ 131071
+ 262143
+ 524287
+ 1048575
+ 2097151
+ 4194303
+ 8388607
+ 16777215
+
+ 33554431
+ 67108863
+ 134217727
+ 268435455
+ 536870911
+ 1073741823
+ 2147483647
+ 4294967295
+// 4294967296 is too big
+// 8589934592
+};
+
+// Powers of two
+const objid c_pow2 := objid {
+ 1
+ 2
+ 4
+ 8
+ 16
+ 32
+ 64
+ 128
+ 256
+
+ 512
+ 1024
+ 2048
+ 4096
+ 8192
+ 16384
+ 32768
+ 65536
+
+ 131072
+ 262144
+ 524288
+ 1048576
+ 2097152
+ 4194304
+ 8388608
+ 16777216
+
+ 33554432
+ 67108864
+ 134217728
+ 268435456
+ 536870912
+ 1073741824
+ 2147483648
+
+// 4294967296 is too big
+// 8589934592
+};
+
+const objid c_0_1_infinity // for small values of infinity
+ := objid { 0 1 4294967295 }
+
+const octetstring expected := '0606018FFFFFFF7F'O
+
+// encoding of { 0 1 70368744177663 } a.k.a. { 0 1 0x3FFFFFFFFFFF }
+const octetstring bigger := '0608018FFFFFFFFFFF7F'O
+
+
+testcase objidSubtypes() runs on objidOper_comptype {
+ if (c_etsiMobNet != c_etsiNet) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+//external function indexer(in objid o, in integer idx) return integer;
+
+//testcase encdec() runs on objidOper_comptype
+//{
+// var octetstring os := enco(c_0_1_infinity);
+// //action(os);
+// if (os == expected) { setverdict(pass); }
+// else { setverdict(fail, match(os, expected)); }
+//
+// var objid oi := deco(expected);
+// //action(oi);
+// if (oi == c_0_1_infinity) { setverdict(pass); }
+// else { setverdict(fail, match(oi, c_0_1_infinity)); }
+//
+// // Decode the bigger objid. The value will overflow and it will be clamped
+// // to 2**32-1 (4294967295) as long as objid is limited to 32bits.
+// oi := deco(bigger);
+// action(oi);
+//
+// if (sizeof(oi) != sizeof(c_0_1_infinity)) {
+// setverdict(fail, "Number of objid components: ",
+// match(sizeof(oi), sizeof(c_0_1_infinity)))
+// }
+// else {
+// // All components should look equal
+// for (var integer i := 0; i < sizeof(oi); i := i + 1) {
+// if (indexer(oi, i) == indexer(c_0_1_infinity, i)) { /*setverdict(pass);*/ }
+// else {
+// setverdict(fail, "Mismatch at ", i, ": ",
+// match(indexer(oi, i), indexer(c_0_1_infinity, i)));
+// }
+// }
+// }
+//
+// // However, the (decoded) oi has an overflow whereas c_0_1_infinity does not,
+// // therefore they (should) compare as not equal.
+// if (oi != c_0_1_infinity) { setverdict(pass, match(oi, c_0_1_infinity)); }
+// else { setverdict(fail, match(oi, c_0_1_infinity)); }
+//
+// os := enco(c_bits);
+// oi := deco(os);
+//
+// if (sizeof(oi) != sizeof(c_bits)) {
+// setverdict(fail, "Number of objid components: ",
+// match(sizeof(oi), sizeof(c_bits)))
+// }
+// else {
+// // All components should look equal
+// for (var integer i := 0; i < sizeof(oi); i := i + 1) {
+// if (indexer(oi, i) == indexer(c_bits, i)) { /*setverdict(pass);*/ }
+// else {
+// setverdict(fail, "Mismatch at ", i, ": ",
+// match(indexer(oi, i), indexer(c_bits, i)));
+// }
+// }
+// }
+//
+// os := enco(c_pow2);
+// oi := deco(os);
+//
+// if (sizeof(oi) != sizeof(c_pow2)) {
+// setverdict(fail, "Number of objid components: ",
+// match(sizeof(oi), sizeof(c_pow2)))
+// }
+// else {
+// // All components should look equal
+// for (var integer i := 0; i < sizeof(oi); i := i + 1) {
+// if (indexer(oi, i) == indexer(c_pow2, i)) { /*setverdict(pass);*/ }
+// else {
+// setverdict(fail, "Mismatch at ", i, ": ",
+// match(indexer(oi, i), indexer(c_pow2, i)));
+// }
+// }
+// }
+//
+//}
+
+testcase objidWithVars() runs on objidOper_comptype
+{
+ var integer v1 := 1;
+ var integer v2 := 20;
+ var integer v3 := 300;
+ var integer v4 := -87;
+ const integer c1 := 0;
+ var objid o1 := objid { c1 v1 };
+
+ if (o1 == objid { 0 1 }) { setverdict(pass); }
+ else { setverdict(fail, o1, " != ", objid { 0 1 }); }
+
+ if (objid { c1 3 v2 } == objid { 0 3 20 }) { setverdict(pass); }
+ else { setverdict(fail, objid { c1 3 v2 }, " != ", objid { 0 3 20 }); }
+
+ if (objid { c1 2 3 } == objid { 0 2 3 }) { setverdict(pass); }
+ else { setverdict(fail, objid { c1 2 3 }, " != ", objid { 0 2 3 }); }
+
+ var objid o2 := objid { 0 v1 };
+ if (o1 == o2) { setverdict(pass); }
+ else { setverdict(fail, o1, " != ", o2); }
+
+// @try {
+// var objid o_bad := objid { v1 v2 v3 v4 };
+// setverdict(fail, "error expected when creating ", objid { v1 v2 v3 v4 });
+// }
+// @catch (msg) {
+// if (match(msg, pattern "*Dynamic test case error: An OBJECT IDENTIFIER component cannot be negative")) { setverdict(pass); }
+// else { setverdict(fail, "unexpected error: ", msg); }
+// }
+
+ var template objid to1 := (objid { 0 1 6 }, objid { v1 6 v3 });
+
+ if (match(objid { 1 6 v3 }, to1)) { setverdict(pass); }
+ else { setverdict(fail, objid { 1 6 v3 }, " doesn't match ", to1); }
+
+ if (match(objid { 1 2 3 }, to1)) { setverdict(fail, objid { 1 2 3 }, " matches ", to1); }
+ else { setverdict(pass); }
+}
+
+control {
+ execute(objidSubtypes());
+// execute(encdec());
+ execute(objidWithVars());
+}
+
+}
diff --git a/Regression_Test_java/src/ToctetstrOper.ttcn b/Regression_Test_java/src/ToctetstrOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..0ad60ed3d90c204ef7468b070f11f65580617f8b
--- /dev/null
+++ b/Regression_Test_java/src/ToctetstrOper.ttcn
@@ -0,0 +1,568 @@
+/******************************************************************************
+ * 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
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module ToctetstrOper
+{type component octetstrOper_comptype { };
+const octetstring ToctetstrOper_const1:='AA11'O;
+
+testcase octetstrAssign() runs on octetstrOper_comptype
+{ var octetstring x1:='0BF2'O;
+ var octetstring x2,x3,x4;
+ x4:='AA'O;
+ x2:='AB54'O;
+ x3:=''O;
+ x4:='AABB'O;
+ if (x1=='0BF2'O) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+ if (x2=='AB54'O) {setverdict(pass);} //later
+ else {setverdict(fail);}
+ if (x3==''O) {setverdict(pass);} //empty string
+ else {setverdict(fail);}
+ if (x4=='AABB'O) {setverdict(pass);} //with different size
+ else {setverdict(fail);}
+}
+
+testcase octetstrAssignElem() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3,x4,x5,x6,x7;
+ x1:='AAAAAA'O;
+ x4:='777777'O;
+ x2:='BBBBBB'O;
+ x5:='AABBCC'O;
+ x6:='AABBCC'O;
+ x3:='66'O;
+ x3:=x5[1];
+ x1[1]:='0C'O;
+ x4[1]:=x2[2];
+ x7:='66'O;
+ x5[0]:=x7;
+ x6[3]:='DD'O;
+ if (x6[0]=='AA'O) {setverdict(pass);} //accessing of an element
+ else {setverdict(fail);}
+ if (x3=='BB'O) {setverdict(pass);} //change string to element
+ else {setverdict(fail);}
+ if (x1=='AA0CAA'O) {setverdict(pass);} //change element to value
+ else {setverdict(fail);}
+ if (x4=='77BB77'O) {setverdict(pass);} //change element to element
+ else {setverdict(fail);}
+ if (x5=='66BBCC'O) {setverdict(pass);} //change element to string
+ else {setverdict(fail);}
+ if (x6=='AABBCCDD'O) {setverdict(pass);} //adding element
+ else {setverdict(fail);}
+}
+
+testcase octetstrLengthof() runs on octetstrOper_comptype
+{ var octetstring x1:='AABB'O;
+ var octetstring x2,x3,x4,x5;
+ x2:='AABB'O;
+ x4:='AA'O;
+ x5:='AABB'O;
+ x3:=''O;
+ x4:='AABB'O;
+ x5[2]:='CC'O;
+ if (lengthof(x1)==2) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+ if (lengthof(x2)==2) {setverdict(pass);} //later
+ else {setverdict(fail);}
+ if (lengthof(x3)==0) {setverdict(pass);} //empty string
+ else {setverdict(fail);}
+ if (lengthof(x4)==2) {setverdict(pass);} //change of size
+ else {setverdict(fail);}
+ if (lengthof(x5)==3) {setverdict(pass);} //add element
+ else {setverdict(fail);}
+}
+
+testcase octetstrConst() runs on octetstrOper_comptype {
+const octetstring ToctetstrOper_const3:='DD22'O;
+if (ToctetstrOper_const1=='AA11'O) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (ToctetstrOper_const3=='DD22'O) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+}
+
+testcase octetstrComp_str_str() runs on octetstrOper_comptype
+{var octetstring x1,x2,x3;
+ x1:='A1B2'O;
+ x2:='A1B2'O;
+ x3:='A1B2C3'O;
+ if (x1==x2) {setverdict(pass);} //equality, equals
+ else {setverdict(fail);}
+ if (not(x3==x2)) {setverdict(pass);} //equality, not equals
+ else {setverdict(fail);}
+ if (x1!=x3) {setverdict(pass);} //non-equality, not equals
+ else {setverdict(fail);}
+ if (not(x1!=x2)) {setverdict(pass);} //non-equality, equals
+ else {setverdict(fail);}
+}
+
+testcase octetstrComp_el_str() runs on octetstrOper_comptype
+{var octetstring x1,x2,x3;
+ x1:='A1B2'O;
+ x2:='A1'O;
+ x3:='B2'O;
+ if (x1[1]==x3) {setverdict(pass);} //equality, equals
+ else {setverdict(fail);}
+ if (not(x1[0]==x3)) {setverdict(pass);} //equality, not equals
+ else {setverdict(fail);}
+ if (x1[0]!=x3) {setverdict(pass);} //non-equality, not equals
+ else {setverdict(fail);}
+ if (not(x1[1]!=x3)) {setverdict(pass);} //non-equality, equals
+ else {setverdict(fail);}
+}
+
+
+testcase octetstrComp_str_el() runs on octetstrOper_comptype
+{var octetstring x1,x2;
+ x1:='A1B2'O;
+ x2:='A1'O;
+ if (x2==x1[0]) {setverdict(pass);} //equality, equals
+ else {setverdict(fail);}
+ if (not(x2==x1[1])) {setverdict(pass);} //equality, not equals
+ else {setverdict(fail);}
+ if (x2!=x1[1]) {setverdict(pass);} //non-equality, not equals
+ else {setverdict(fail);}
+ if (not(x2!=x1[0])) {setverdict(pass);} //non-equality, equals
+ else {setverdict(fail);}
+}
+
+testcase octetstrComp_el_el() runs on octetstrOper_comptype
+{var octetstring x1,x2;
+ x1:='A1B2'O;
+ x2:='A1B2'O;
+ if (x1[1]==x2[1]) {setverdict(pass);} //equality, equals
+ else {setverdict(fail);}
+ if (not(x1[0]==x2[1])) {setverdict(pass);} //equality, not equals
+ else {setverdict(fail);}
+ if (x1[1]!=x2[0]) {setverdict(pass);} //non-equality, not equals
+ else {setverdict(fail);}
+ if (not(x1[1]!=x2[1])) {setverdict(pass);} //non-equality, equals
+ else {setverdict(fail);}
+}
+
+testcase octetstrConcat() runs on octetstrOper_comptype
+{var octetstring x1,x2,x3,x4,x5,x6;
+ x1:='A1B2'O;
+ x2:='C3D4'O;
+ x3:= x1 & x2;
+ x4:=x1&x2[1];
+ x5:=x1[1]&x2;
+ x6:=x1[0]&x2[1];
+ if ((x3=='A1B2C3D4'O)and(lengthof(x3)==4)) {setverdict(pass);} //string&string
+ else {setverdict(fail);}
+ if ((x4=='A1B2D4'O)and(lengthof(x4)==3)) {setverdict(pass);} //string&element
+ else {setverdict(fail);}
+ if ((x5=='B2C3D4'O)and(lengthof(x5)==3)) {setverdict(pass);} //element&string
+ else {setverdict(fail);}
+ if ((x6=='A1D4'O)and(lengthof(x6)==2)) {setverdict(pass);} //element&element
+ else {setverdict(fail);}
+}
+
+testcase octetstrNot_str() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:='0123456789ABCDEF'O;
+ x2:=not4b(x1);
+ if (x2=='FEDCBA9876543210'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrNot_el() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3;
+ x1:='A1B2C3'O;
+ x2:=not4b(x1[1]);
+ x3:=not4b(x1[2]);
+ if ((x2=='4D'O)and(x3=='3C'O)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase octetstrAnd_str_str() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3;
+ x1:='8DE9A3'O;
+ x2:='7352B6'O;
+ x3:=x1 and4b x2;
+ if (x3=='0140A2'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrAnd_el_str() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3,x4;
+ x1:='A3A3'O;
+ x2:='B6'O;
+ x3:=x1[0] and4b 'B6'O;
+ x4:=x1[0] and4b x2;
+ if (x3=='A2'O) {setverdict(pass);} //element_value
+ else {setverdict(fail);}
+ if (x4=='A2'O) {setverdict(pass);} //element_string
+ else {setverdict(fail);}
+}
+
+
+testcase octetstrAnd_str_el() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3,x4;
+ x1:='A3A3'O;
+ x2:='B6'O;
+ x3:='B6'O and4b x1[0];
+ x4:=x2 and4b x1[1];
+ if (x3=='A2'O) {setverdict(pass);} //value_element
+ else {setverdict(fail);}
+ if (x4=='A2'O) {setverdict(pass);} //string_element
+ else {setverdict(fail);}
+}
+
+testcase octetstrAnd_el_el() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3;
+ x1:='A3A3'O;
+ x2:='B6B6'O;
+ x3:=x2[0] and4b x1[0];
+ if (x3=='A2'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrOr_str_str() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3;
+ x1:='8DE9A3'O;
+ x2:='7352B6'O;
+ x3:=x1 or4b x2;
+ if (x3=='FFFBB7'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrOr_el_str() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3,x4;
+ x1:='A3A3'O;
+ x2:='B6'O;
+ x3:=x1[0] or4b 'B6'O;
+ x4:=x1[1] or4b x2;
+ if (x3=='B7'O) {setverdict(pass);} //element_value
+ else {setverdict(fail);}
+ if (x4=='B7'O) {setverdict(pass);} //element_string
+ else {setverdict(fail);}
+}
+
+testcase octetstrOr_str_el() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3,x4;
+ x1:='A3A3'O;
+ x2:='B6'O;
+ x3:='B6'O or4b x1[0];
+ x4:=x2 or4b x1[1];
+ if (x3=='B7'O) {setverdict(pass);} //value_element
+ else {setverdict(fail);}
+ if (x4=='B7'O) {setverdict(pass);} //string_element
+ else {setverdict(fail);}
+}
+
+testcase octetstrOr_el_el() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3;
+ x1:='3333'O;
+ x2:='B6B6'O;
+ x3:=x2[0] or4b x1[1];
+ if ((x3=='B7'O)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase octetstrXor_str_str() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3;
+ x1:='ACDE9833'O;
+ x2:='B8352765'O;
+ x3:=x1 xor4b x2;
+ if (x3=='14EBBF56'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrXor_el_str() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3,x4;
+ x1:='A3A3'O;
+ x2:='B6'O;
+ x3:=x1[0] xor4b 'B6'O;
+ x4:=x1[1] xor4b x2;
+ if (x3=='15'O) {setverdict(pass);} //element_value
+ else {setverdict(fail);}
+ if (x4=='15'O) {setverdict(pass);} //element_string
+ else {setverdict(fail);}
+
+}
+
+testcase octetstrXor_str_el() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3,x4;
+ x1:='C3C3'O;
+ x2:='86'O;
+ x3:='86'O xor4b x1[0];
+ x4:=x2 xor4b x1[1];
+ if (x3=='45'O) {setverdict(pass);} //value_element
+ else {setverdict(fail);}
+ if (x4=='45'O) {setverdict(pass);} //string_element
+ else {setverdict(fail);}
+}
+
+testcase octetstrXor_el_el() runs on octetstrOper_comptype
+{ var octetstring x1,x2,x3;
+ x1:='D3D3'O;
+ x2:='3636'O;
+ x3:=x2[0] xor4b x1[1];
+ if ((x3=='E5'O)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrShiftRight1() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:='ABCDEF'O;
+ x2:=x1 >> 1;
+ if (x2=='00ABCD'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrShiftRight2() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:='ABCDEF'O;
+ x2:=x1 >> 2;
+ if (x2=='0000AB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrShiftRightSum() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:='ABCDEF'O;
+ x2:=x1 >> (1+1);
+ if (x2=='0000AB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrShiftRightEmpty() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:=''O;
+ x2:=x1 >> (1);
+ if (x2==''O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase octetstrShiftLeft1() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:='ABCDEF'O;
+ x2:=x1 << 1;
+ if (x2=='CDEF00'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrShiftLeft2() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:='ABCDEF'O;
+ x2:=x1 << 2;
+ if (x2=='EF0000'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrShiftLeftSum() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:='ABCDEF'O;
+ x2:=x1 << (1+1);
+ if (x2=='EF0000'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrShiftLeftEmpty() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:=''O;
+ x2:=x1 << (1);
+ if (x2==''O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrRotateRight1() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:='ABCDEF'O;
+ x2:=x1 @> 1;
+ if (x2=='EFABCD'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrRotateRight2() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:='ABCDEF'O;
+ x2:=x1 @> 2;
+ if (x2=='CDEFAB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrRotateRightSum() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:='ABCDEF'O;
+ x2:=x1 @> (1+1);
+ if (x2=='CDEFAB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrRotateRightEmpty() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:=''O;
+ x2:=x1 @> (1);
+ if (x2==''O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase octetstrRotateLeft1() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:='ABCDEF'O;
+ x2:=x1 <@ 1;
+ if (x2=='CDEFAB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrRotateLeft2() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:='ABCDEF'O;
+ x2:=x1 <@ 2;
+ if (x2=='EFABCD'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrRotateLeftSum() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:='ABCDEF'O;
+ x2:=x1 <@ (1+1);
+ if (x2=='EFABCD'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase octetstrRotateLeftEmpty() runs on octetstrOper_comptype
+{ var octetstring x1,x2;
+ x1:=''O;
+ x2:=x1 <@ (1);
+ if (x2==''O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+const integer c_myval1 := 16
+type octetstring myostr1
+type octetstring myostr2 length(1)
+type octetstring myostr3 length(0..1)
+type octetstring myostr4 ('00'O, '01'O, '10'O, '11'O) length(1)
+// Extending restrictions shouldn't be allowed.
+type myostr4 myostr5 (int2oct(c_myval1, 1)) length(1)
+type octetstring myostr6 length(0..infinity)
+type octetstring myostr7 (''O, '00'O, '01'O)
+type octetstring myostr8 (myostr3, myostr4)
+
+const myostr8 c_myostr1 := '00'O
+
+template myostr8 t_myostr1 := '00'O
+template myostr6 t_myostr2 := '0011'O length(2)
+template myostr4 t_myostr3 := t_myostr1 length(1)
+
+function f_ostr1() return myostr6 {
+ var myostr3 v_myostr1 := '00'O
+ return v_myostr1 & '11'O
+}
+
+testcase octetstrSubtypes() runs on octetstrOper_comptype {
+ var template myostr2 vt_myostr1 := '00'O // Length only.
+ var template myostr3 vt_myostr2 := ''O // Length with range.
+ var template myostr4 vt_myostr3 := vt_myostr1 // Value list with length.
+ var template myostr7 vt_myostr4 := vt_myostr2 // Value list only.
+ var myostr2 v_myostr1 := '00'O
+ var myostr3 v_myostr2 := ''O
+ var myostr4 v_myostr3 := v_myostr1
+ var myostr7 v_myostr4 := v_myostr2
+
+ if (valueof(vt_myostr1) == v_myostr1 and v_myostr2 == valueof(vt_myostr2)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (valueof(vt_myostr3) == v_myostr3 and v_myostr4 == valueof(vt_myostr4)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (f_ostr1() == '0011'O and '00'O & '11'O == f_ostr1()) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+testcase octetstrIsvalue() runs on octetstrOper_comptype{
+ var octetstring ostr0;
+ var octetstring ostr1 := '1234'O;
+ var template octetstring tostr;
+
+ if ( isvalue(ostr0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(ostr1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(tostr) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+testcase octetstrIsbound() runs on octetstrOper_comptype{
+ var octetstring ostr0;
+ var octetstring ostr1 := '1234'O;
+ var template octetstring tostr;
+
+ if ( isbound(ostr0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(ostr0[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(ostr1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(tostr) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+testcase tc_simple_octetstring_unbound() runs on octetstrOper_comptype {
+ var octetstring vl_o1;
+ if(ispresent(vl_o1)){setverdict(fail)} else {setverdict(pass)} //fail
+ var octetstring vl_o2:='ABBA'O;
+ if(ispresent(vl_o2)) {setverdict(pass)} else {setverdict(fail)} //not logged
+ var octetstring vl_o3;
+ if(isbound(vl_o3)){setverdict(fail)} else {setverdict(pass)}
+ vl_o3:='ABBA'O;
+ if(isbound(vl_o3)) {setverdict(pass)} else {setverdict(fail)}
+}
+
+control {
+ const octetstring cl_1:='AA11'O;
+ var octetstring vl_1;
+
+ execute(octetstrAssign());
+ execute(octetstrAssignElem());
+ execute(octetstrLengthof());
+ execute(octetstrConst());
+ execute(octetstrComp_str_str());
+ execute(octetstrComp_el_str());
+ execute(octetstrComp_str_el());
+ execute(octetstrComp_el_el());
+ execute(octetstrConcat());
+ execute(octetstrNot_str());
+ execute(octetstrNot_el());
+ execute(octetstrAnd_str_str());
+ execute(octetstrAnd_el_str());
+ execute(octetstrAnd_str_el());
+ execute(octetstrAnd_el_el());
+ execute(octetstrOr_str_str());
+ execute(octetstrOr_el_str());
+ execute(octetstrOr_str_el());
+ execute(octetstrOr_el_el());
+ execute(octetstrXor_str_str());
+ execute(octetstrXor_el_str());
+ execute(octetstrXor_str_el());
+ execute(octetstrXor_el_el());
+ execute(octetstrShiftRight1());
+ execute(octetstrShiftRight2());
+ execute(octetstrShiftRightSum());
+ execute(octetstrShiftRightEmpty());
+ execute(octetstrShiftLeft1());
+ execute(octetstrShiftLeft2());
+ execute(octetstrShiftLeftSum());
+ execute(octetstrShiftLeftEmpty());
+ execute(octetstrRotateRight1());
+ execute(octetstrRotateRight2());
+ execute(octetstrRotateRightSum());
+ execute(octetstrRotateRightEmpty());
+ execute(octetstrRotateLeft1());
+ execute(octetstrRotateLeft2());
+ execute(octetstrRotateLeftSum());
+ execute(octetstrRotateLeftEmpty());
+ execute(octetstrSubtypes());
+ execute(octetstrIsvalue());
+ execute(octetstrIsbound());
+ execute(tc_simple_octetstring_unbound());
+}
+}
diff --git a/Regression_Test_java/src/TrecofOper.ttcn b/Regression_Test_java/src/TrecofOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..03d906d5a51ae58d729e7ca4d6111372e6c9704c
--- /dev/null
+++ b/Regression_Test_java/src/TrecofOper.ttcn
@@ -0,0 +1,1426 @@
+/******************************************************************************
+ * 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
+ * Beres, Szabolcs
+ * Godar, Marton
+ * Kovacs, Ferenc
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TrecofOper {
+// ********** Type definitions *********************
+type component recofOper_mycomp {};
+type enumerated recofOper_myenum {xx1,xx2,xx3};
+type record recofOper_trecord {
+ integer x1 optional,
+ float x2 };
+type record of octetstring recofOper_trecof;
+type set recofOper_tset {
+ integer x1,
+ float x2 optional };
+type set of charstring recofOper_tsetof;
+type union recofOper_tunion {
+ integer x1,
+ float x2 };
+type record of integer recofOper_myrecof1; // record of basic types
+type record of recofOper_myenum recofOper_myrecof2; // record of enum
+type record of recofOper_trecord recofOper_myrecof3; // record of record
+type record of recofOper_trecof recofOper_myrecof4; // record of record of
+type record of recofOper_tset recofOper_myrecof5; // record of set
+type record of recofOper_tsetof recofOper_myrecof6; // record of set of
+type record of recofOper_tunion recofOper_myrecof7; // record of union
+type record length (3)
+ of record length (3)
+ of record length (3) of integer threeD;
+// *************** Constanst ***********************
+const recofOper_trecord recofOper_temp1:={ x1:=omit, x2:=3.4 };
+const recofOper_trecof recofOper_temp2:={ 'AF12'O };
+const recofOper_tset recofOper_temp3:={ x1:=234, x2:=1.9};
+const recofOper_tsetof recofOper_temp4:={"f","8"};
+const recofOper_tunion recofOper_temp5:={ x2:=1.3 };
+const recofOper_myrecof1 recofOper_const1:={ 1,2 } //record of basic types
+const recofOper_myrecof2 recofOper_const2:={ xx2, xx1 }
+const recofOper_myrecof3 recofOper_const4:={ //record of record
+ { x1:=1, x2:=1.2 },recofOper_temp1 };
+const recofOper_myrecof4 recofOper_const6:={ //record of record of
+ { '12AB'O, 'CD12'O }, recofOper_temp2 };
+const recofOper_myrecof5 recofOper_const8:={ //record of set
+ { x1:=2, x2:=1.3}, recofOper_temp3 };
+const recofOper_myrecof6 recofOper_const10:={ //record of set of
+ {"a","b"}, recofOper_temp4 }; //{"f","8"},
+const recofOper_myrecof7 recofOper_const12:={ //record of union
+ { x1 :=3 }, recofOper_temp5 }; //{ x2:=1.3 }
+
+testcase recofAssign() runs on recofOper_mycomp{
+var recofOper_myrecof1 x1:={ 12,34} //record of basic types
+var recofOper_myrecof1 x2,x3,x4;
+x2:={ 32, 12 };
+x3:={12};
+x3:={23,21};
+x4:={};
+if (x1[0]==12) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1[1]==34) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0]==32) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2[1]==12) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3[0]==23) {setverdict(pass);} //later, change size
+ else {setverdict(fail);}
+if (x3[1]==21) {setverdict(pass);}
+ else {setverdict(fail);}
+//if (x4=={}) {setverdict(pass);} //empty record of
+// else {setverdict(fail);}
+}
+
+testcase recofReAssign() runs on recofOper_mycomp
+{
+ var recofOper_myrecof1 x := { 1, 2, 3, 4 };
+ // assigning a new value that is shorter than the previous
+ x := { 1, 5, 3 };
+ if (sizeof(x) == 3) { setverdict(pass); }
+ else { setverdict(fail); }
+ if (x[0] == 1) { setverdict(pass); }
+ else { setverdict(fail); }
+ if (x[1] == 5) { setverdict(pass); }
+ else { setverdict(fail); }
+ if (x[2] == 3) { setverdict(pass); }
+ else { setverdict(fail); }
+ x := { 6 };
+ if (sizeof(x) == 1) { setverdict(pass); }
+ else { setverdict(fail); }
+ if (x[0] == 6) { setverdict(pass); }
+ x := { };
+ if (sizeof(x) == 0) { setverdict(pass); }
+ else { setverdict(fail); }
+}
+
+testcase recofAssignEnum() runs on recofOper_mycomp{
+var recofOper_myrecof2 x1:={ xx2 } //record of enum
+var recofOper_myrecof2 x2;
+x2:={xx2,xx1};
+//at declaration
+if (x1[0]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+//later
+if (x2[0]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1]==xx1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofAssignRec() runs on recofOper_mycomp{
+var recofOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var recofOper_myrecof3 x1:={ //record of record
+ { x1:=1, x2:=1.2 }, temp1 };
+var recofOper_myrecof3 x2;
+x2:={ { x1:=1, x2:=1.2 }, temp1 };
+if (x1[0].x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1]==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0].x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1].x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofAssignRecof() runs on recofOper_mycomp{
+var recofOper_trecof temp2:={'AF12'O};
+var recofOper_myrecof4 x1:={ //record of record of
+ { '12AB'O, 'CD12'O }, temp2 };
+var recofOper_myrecof4 x2;
+x2:={ { '12AB'O, 'CD12'O }, temp2 };
+if (x1[0][0]=='12AB'O) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1]==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0][0]=='12AB'O) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1][0]=='AF12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofAssignSet() runs on recofOper_mycomp{
+var recofOper_tset temp1:={ x1:=2, x2:=omit };
+var recofOper_myrecof5 x1:={ //record of set
+ { x1:=1, x2:=1.2 }, temp1 };
+var recofOper_myrecof5 x2;
+x2:={ { x1:=1, x2:=1.2 }, temp1 };
+if (x1[0].x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1]==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0].x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1].x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2[1].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofAssignSetof() runs on recofOper_mycomp{
+var recofOper_tsetof temp2:={"a","7"};
+var recofOper_myrecof6 x1:={ //record of set of
+ { "1", "a" }, temp2 };
+var recofOper_myrecof6 x2;
+x2:={ { "1", "a" }, temp2 };
+if (x1[0][0]=="1") {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1[0][1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1]==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0][0]=="1") {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2[0][1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1][0]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1][1]=="7") {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofAssignUnion() runs on recofOper_mycomp{
+var recofOper_tunion temp5 := {x2:=1.3}
+var recofOper_myrecof7 x1:={ //record of union
+ { x1 :=3 }, temp5 }; //{ x2:=1.3
+var recofOper_myrecof7 x2;
+x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
+if (x1[0].x1==3) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (ischosen(x1[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1]==temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0].x1==3) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (ischosen(x2[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2[1].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofAssignElem() runs on recofOper_mycomp{
+var recofOper_myrecof1 x1,x2,x3,x4,x5; //record of basic types
+x1:={ 3, 2 };
+x2:={ 1, 2 };
+x3:=x2;
+x4:=x2;
+x5:={2};
+x2[0]:=3; //change element to value
+x3[0]:=x1[0]; //change element to element
+x4[2]:=2; // add element
+x5[2]:=3; // out of order
+if (x1[1]==2) {setverdict(pass);} //accessing individual element
+ else {setverdict(fail);}
+if (x2[0]==3) {setverdict(pass);} // change element to value
+ else {setverdict(fail);}
+if (x2[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3[0]==3) {setverdict(pass);} // change element to element
+ else {setverdict(fail);}
+if (x3[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4[0]==1) {setverdict(pass);} // add element
+ else {setverdict(fail);}
+if (x4[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4[2]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x5[2]==3) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase recofAssignElemEnum() runs on recofOper_mycomp{
+var recofOper_myrecof2 x1, x2,x3; //record of enumerated
+x1:={ xx1, xx2 };
+x2:={xx1, xx2};
+x3:={};
+x1[0]:=xx3; //change element
+x2[2]:=xx3; // add element
+x3[2]:=xx3; // out of order
+if (x1[0]==xx3) {setverdict(pass);} // change element
+ else {setverdict(fail);}
+if (x1[1]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0]==xx1) {setverdict(pass);} // add element
+ else {setverdict(fail);}
+if (x2[1]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[2]==xx3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3[2]==xx3) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase recofAssignElemRec() runs on recofOper_mycomp{
+//var recofOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var recofOper_myrecof3 x1,x2,x3; //record of record
+x1:={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
+x2:=x1;
+x1[0].x1:=2;
+//temp1.x1:=3;
+x1[1].x1:=3;
+x2[2]:= {x1:=2, x2:=1.3}; // add element
+x3[1]:= {x1:=2, x2:=1.3}; //out of order
+if (x1[0].x1==2) {setverdict(pass);} // change element
+ else {setverdict(fail);}
+if (x1[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1].x1==3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1].x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0].x1==1) {setverdict(pass);} //add element
+ else {setverdict(fail);}
+if (x2[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1].x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[2].x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[2].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3[1].x1==2) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+if (x3[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase recofAssignElemRecof() runs on recofOper_mycomp{
+var recofOper_myrecof4 x1,x2,x3; //record of record of
+x1:={ { '12AB'O, 'CD12'O }, { 'ABCD'O } };
+x2:=x1;
+x1[0][1]:='34AB'O; //change element
+x2[2]:={ '1234'O}; //add element
+x3[2]:={'12CD'O}; //out of order
+if (x1[0][0]=='12AB'O) {setverdict(pass);} // change element
+ else {setverdict(fail);}
+if (x1[0][1]=='34AB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1][0]=='ABCD'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0][0]=='12AB'O) {setverdict(pass);} // add element
+ else {setverdict(fail);}
+if (x2[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1][0]=='ABCD'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[2][0]=='1234'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3[2][0]=='12CD'O) {setverdict(pass);} //out of order
+ else {setverdict(fail);}}
+
+testcase recofAssignElemSet() runs on recofOper_mycomp{
+var recofOper_myrecof5 x1,x2,x3 //record of set
+x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
+x2:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
+x1[0].x2:=3.4; //change element
+x2[2]:={ x1:=2, x2:=1.3 }; // add element
+x3[2]:={ x1:=2, x2:=1.3 }; // out of order
+if (x1[0].x1==1) {setverdict(pass);} //change element
+ else {setverdict(fail);}
+if (x1[0].x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1].x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x1[1].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0].x1==1) {setverdict(pass);} //add element
+ else {setverdict(fail);}
+if (x2[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1].x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2[1].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[2].x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[2].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3[2].x1==2) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+if (x3[2].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofAssignElemSetof() runs on recofOper_mycomp{
+var recofOper_tsetof temp2:={"a","7"};
+var recofOper_myrecof6 x1,x2,x3; //record of set of
+x1:={ { "1" }, {"a","7"}};
+x2:={ { "1" }, {"a","7"}};
+x1[0][0]:="h"; // change element
+x2[2]:={"2"}; //add element
+x3[2]:={"2"}; //out of order
+if (x1[0][0]=="h") {setverdict(pass);} //change element
+ else {setverdict(fail);}
+if (x1[1][0]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1][1]=="7") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0][0]=="1") {setverdict(pass);} //add element
+ else {setverdict(fail);}
+if (x2[1][0]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1][1]=="7") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[2][0]=="2") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3[2][0]=="2") {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase recofAssignElemUnion() runs on recofOper_mycomp{
+var recofOper_tunion temp5 := {x2:=1.3}
+var recofOper_myrecof7 x1,x2,x3; //record of union
+x1:={ {x1 :=3 }, {x2:=1.3} };
+x2:={ {x1 :=3 }, {x2:=1.3} };
+x1[0].x2:=3.4; //change element
+x2[2]:={ x2:=1.4}; // add element
+x3[2]:={ x2:=1.4}; // out of order
+if (x1[0].x2==3.4) {setverdict(pass);} //change element
+ else {setverdict(fail);}
+if (ischosen(x1[0].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1[0].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1[1].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0].x1==3) {setverdict(pass);} //add element
+ else {setverdict(fail);}
+if (ischosen(x2[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2[1].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[2].x2==1.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2[2].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2[2].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3[2].x2==1.4) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+if (ischosen(x3[2].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x3[2].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofConst() runs on recofOper_mycomp{
+const recofOper_myrecof1 const1:={1,2,3} //record of basic types
+if (recofOper_const1[0]==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (recofOper_const1[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1[0]==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const1[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1[2]==3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofConstEnum() runs on recofOper_mycomp{
+const recofOper_myrecof2 const1:={xx1,xx2,xx3} //record of enumerated
+if (recofOper_const2[0]==xx2) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (recofOper_const2[1]==xx1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1[0]==xx1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const1[1]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1[2]==xx3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofConstRec() runs on recofOper_mycomp{
+const recofOper_myrecof3 const4:={ //record of record
+ { x1:=1, x2:=1.2 }, recofOper_temp1 };
+if (recofOper_const4[0].x1==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (recofOper_const4[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recofOper_const4[1]==recofOper_temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const4[0].x1==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const4[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const4[1]==recofOper_temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofConstRecof() runs on recofOper_mycomp{
+const recofOper_myrecof4 const6:={ //record of record of
+ { '12AB'O, 'CD12'O }, recofOper_temp2 };
+if (recofOper_const6[0][0]=='12AB'O) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (recofOper_const6[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recofOper_const6[1]==recofOper_temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const6[0][0]=='12AB'O) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const6[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const6[1]==recofOper_temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofConstSet() runs on recofOper_mycomp{
+const recofOper_myrecof5 const8:={ //record of set
+ { x1:=2, x2:=1.3}, recofOper_temp3 };
+if (recofOper_const8[0].x1==2) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (recofOper_const8[0].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recofOper_const8[1]==recofOper_temp3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const8[0].x1==2) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const8[0].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const8[1]==recofOper_temp3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofConstSetof() runs on recofOper_mycomp{
+const recofOper_myrecof6 const10:={ //record of set of
+ {"a","b"}, {"f","8"} };
+if (recofOper_const10[0][0]=="a") {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (recofOper_const10[0][1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (recofOper_const10[1]==recofOper_temp4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const10[0][0]=="a") {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const10[0][1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (const10[1][0]=="f") {setverdict(pass);}
+ else {setverdict(fail);}
+if (const10[1][1]=="8") {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofConstUnion() runs on recofOper_mycomp{
+const recofOper_myrecof7 const12:={ //record of union
+ { x1 :=3 }, { x2:=1.3 } };
+if (recofOper_const12[0].x1==3) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (ischosen(recofOper_const12[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(recofOper_const12[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recofOper_const12[1]==recofOper_temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const12[0].x1==3) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (ischosen(const12[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const12[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const12[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const12[1].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const12[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase recofComp() runs on recofOper_mycomp{
+var recofOper_myrecof1 x1,x2,x3,x4; //record of basic type
+x1:={ 1,2,3 };
+x2:={ 1,2,3 };
+x3:={ 1,2 };
+x4:={3,1,2};
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x4)) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x4) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase recofCompEnum() runs on recofOper_mycomp{
+var recofOper_myrecof2 x1,x2,x3; // record of enumerated
+x1:={ xx1,xx2,xx3 };
+x2:={ xx1,xx2,xx3 };
+x3:={ xx1,xx2 };
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofCompRec() runs on recofOper_mycomp{
+var recofOper_myrecof3 x1,x2,x3; // record of record
+x1 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
+x2 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
+x3 :={ { x1:=2, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase recofCompRecof() runs on recofOper_mycomp{
+var recofOper_myrecof4 x1,x2,x3; //record of record of
+x1:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
+x2:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
+x3:={ { '12AB'O }, {'AF12'O} };
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofCompSet() runs on recofOper_mycomp{
+var recofOper_tset temp1:={ x1:=2, x2:=omit };
+var recofOper_myrecof5 x1,x2,x3; //record of set
+x1:={ { x1:=1, x2:=1.2 }, temp1 };
+x2:={ { x2:=1.2, x1:=1 }, { x1:=2, x2:=omit }};
+x3:={ { x1:=1, x2:=1.2 } };
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x2==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofCompSetof() runs on recofOper_mycomp{
+var recofOper_tsetof temp2:={"a","7"};
+var recofOper_myrecof6 x1,x2,x3; //record of set of
+x1:={ { "1", "a" }, temp2 };
+x2:={ { "1", "a" }, {"a","7"} };
+x3:={ { "1", "a" } };
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x2==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofCompUnion() runs on recofOper_mycomp{
+var recofOper_tunion temp5 := {x2:=1.3}
+var recofOper_myrecof7 x1,x2,x3; //record of union
+x1:={ { x1 :=3 }, { x2:=1.3 } };
+x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
+x3:={ { x2 :=3.9 },temp5 }; //{ x2:=1.3 }
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofEmpty() runs on recofOper_mycomp{
+ var recofOper_myrecof1 vl_list := {}
+ if (vl_list == {}) {setverdict(pass)}
+ else {setverdict(fail)}
+ if ({} == vl_list) {setverdict(pass)}
+ else {setverdict(fail)}
+}
+
+testcase recofListOperator() runs on recofOper_mycomp{
+ var recofOper_myrecof1 x1;
+ var recofOper_myrecof1 x2,x3,x4,x5,x6;
+ var recofOper_myrecof1 res1, res2, res3, res4, res5;
+ x1:={1,2};
+ x2:={1,2};
+ x3:={1};
+ x4:={1};
+ x4[1]:=3;
+ x5:={};
+ x6[2]:=1;
+ res1 := x1 & x2;
+ res2 := x2 & x3;
+ res3 := x2 & x3 & x5;
+ res4 := x3 & x4;
+ res5 := x1 & {};
+ if (res1 == {1,2,1,2}) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (res2 == {1,2,1}) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (res3 == {1,2,1}) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (res4 == {1,1,3}) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (res5 == {1,2}) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofRotateOperators() runs on recofOper_mycomp{
+ var recofOper_myrecof1 x1:={1,2,3,4,5};
+ var recofOper_myrecof1 x2,x3,x4,x5,x6,x7; //set of basic types
+ x2 := x1 <@ 1;
+ x3 := x1 <@ 10;
+ x4 := x1 <@ 3 <@ 2;
+ x5 := x1 @> 1;
+ x6 := x1 @> 10;
+ x7 := x1 @> 3 @> 2;
+ if (x2 == {2,3,4,5,1}) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x3 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x4 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x5 == {5,1,2,3,4}) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x6 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x7 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recofLengthof() runs on recofOper_mycomp{
+ var recofOper_myrecof1 x1:={1,2};
+ var recofOper_myrecof1 x2,x3,x4,x5,x6; //record of basic types
+ x2:={ 1, 2 };
+ x3:={1};
+ x4:={1};
+ x3:={1,2}; //change size by assignment
+ x4[1]:=3; //change size by adding element
+ x5:={}; //empty record of
+ x6[2]:=1; //out of order
+ if (lengthof(x1)==2) {setverdict(pass);} //assignment at declaration
+ else {setverdict(fail);}
+ if (lengthof(x2)==2) {setverdict(pass);} //assignment later
+ else {setverdict(fail);}
+ if (lengthof(x3)==2) {setverdict(pass);} //change size by assignment
+ else {setverdict(fail);}
+ if (lengthof(x4)==2) {setverdict(pass);} //change size by adding element
+ else {setverdict(fail);}
+ if (lengthof(x5)==0) {setverdict(pass);} //empty record of
+ else {setverdict(fail);}
+ if (lengthof(x6)==3) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+}
+
+testcase recofSizeof() runs on recofOper_mycomp{
+ var recofOper_myrecof1 x1:={1,2};
+ var recofOper_myrecof1 x2,x3,x4,x5,x6; //record of basic types
+ x2:={ 1, 2 };
+ x3:={1};
+ x4:={1};
+ x3:={1,2}; //change size by assignment
+ x4[1]:=3; //change size by adding element
+ x5:={}; //empty record of
+ x6[2]:=1; //out of order
+ if (sizeof(x1)==2) {setverdict(pass);} //assignment at declaration
+ else {setverdict(fail);}
+ if (sizeof(x2)==2) {setverdict(pass);} //assignment later
+ else {setverdict(fail);}
+ if (sizeof(x3)==2) {setverdict(pass);} //change size by assignment
+ else {setverdict(fail);}
+ if (sizeof(x4)==2) {setverdict(pass);} //change size by adding element
+ else {setverdict(fail);}
+ if (sizeof(x5)==0) {setverdict(pass);} //empty record of
+ else {setverdict(fail);}
+ if (sizeof(x6)==3) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+}
+
+testcase recofReplace() runs on recofOper_mycomp{
+ var recofOper_myrecof1 x1:={1,2,3,4,5};
+ var recofOper_myrecof1 a:={8,8,8};
+ var recofOper_myrecof1 x2;
+ x2 := replace(x1,2,3,a);
+ if (x2 == {1,2,8,8,8}) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+// TR: HS22809 - A null value is generated for empty constant arrays by the compiler,
+// this can make calling 'replace' ambiguous (since there's a 'replace' function generated for both the
+// array and its template.
+testcase recofReplaceEmpty() runs on recofOper_mycomp {
+ var recofOper_myrecof1 x1 := { 1, 2, 3 };
+ const recofOper_myrecof1 a := {};
+ var recofOper_myrecof1 x2;
+ x2 := replace(x1, 0, 1, a);
+ if (x2 == { 2, 3 }) { setverdict(pass); }
+ else { setverdict(fail); }
+}
+
+testcase recofSubstr() runs on recofOper_mycomp{
+ var recofOper_myrecof1 x1:={1,2,3,4,5};
+ var recofOper_myrecof1 x2;
+ x2 := substr(x1,2,3);
+ if (x2 == {3,4,5}) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+type record intrec { recofOper_myrecof1 a }
+type record of intrec intreclist
+
+testcase recofIsvalue() runs on recofOper_mycomp{
+ var recofOper_myrecof1 v_def;
+ var recofOper_myrecof1 v_empty := {-,-,-,-,-,-,-,-,-,-};
+ var recofOper_myrecof1 v_full := {1,2,3,4,5,6,7,8,9,10}
+
+ if ( isvalue(v_def) ) { setverdict(fail); }else { setverdict(pass); };
+ if ( isvalue(v_empty) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_empty[1]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_empty[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_full[1]) ) { setverdict(pass); } else { setverdict(fail); };
+
+ v_def[1] := 3;
+ if ( isvalue(v_def) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_def[1]) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
+
+ v_empty[0] := 17; // not empty anymore
+ if ( isvalue(v_empty[0]) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(v_empty) ) { setverdict(fail); } else { setverdict(pass); };
+
+ template intreclist it1 := { { a := { 1, 2, 3 } } };
+ template intreclist it2 modifies it1 := { { a := { 1, 2, -, -, -, 100 } } };
+ template intrec itt1 := { a := { 1, 2, 3 } };
+ template intrec itt2 modifies itt1 := { a := { 1, 2, -, -, -, 100 } };
+ if (isvalue (it1)) {setverdict (pass);}
+ else {setverdict (fail);}
+
+ if (isvalue (it2)) { setverdict (fail);}
+ else { setverdict (pass);}
+
+ if (isvalue (itt1)) {setverdict (pass);}
+ else {setverdict ( fail );}
+
+ if (isvalue (itt2)) { setverdict (fail);}
+ else {setverdict (pass);}
+
+ const threeD d3 := {
+ {
+ { 1,2,3 },
+ { 1,2,3 },
+ { 1,2,3 }
+ },
+ {
+ { 1,2,3 },
+ { 1,2,3 },
+ { 1,2,3 }
+ },
+ {
+ { 1,2,3 },
+ { 1,2,3 },
+ { 1,2,3 }
+ }
+ }
+ var threeD nowhere := {
+ { {-,1,-},{-,1,-},{-,1,-} },
+ { {-,1,-},{-,-,-},{-,1,-} },
+ { {-,1,-},{-,1,-},{-,1,-} }
+
+ }
+ if ( isvalue(nowhere) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(nowhere[1]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(nowhere[1][1]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(nowhere[1][1][1]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( ispresent(nowhere[1][1][1]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(d3) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(d3[0]) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(d3[0][1]) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(d3[0][1][2]) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+testcase recofIsvalue2() runs on recofOper_mycomp{
+ var recofOper_myrecof1 v;
+ if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
+
+ v[3] := 3;
+ if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
+
+ v[2] := 2;
+ if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
+
+ v[1] := 1;
+ if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
+
+ v[0] := 0;
+ if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); };
+
+ v[4] := 4;
+ if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); };
+
+ v[6] := 6; // there is now a hole at 5
+ if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+testcase recofIsbound() runs on recofOper_mycomp{
+ var recofOper_myrecof1 v_def;
+ var recofOper_myrecof1 v_empty := {-,-,-,-,-,-,-,-,-,-};
+ var recofOper_myrecof1 v_full := {1,2,3,4,5,6,7,8,9,10}
+
+ if ( isbound(v_def) ) { setverdict(fail); }else { setverdict(pass); };
+ if ( isbound(v_empty) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(v_empty[1]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(v_empty[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(v_full[1]) ) { setverdict(pass); } else { setverdict(fail); };
+
+ v_def[1] := 3;
+ if ( isbound(v_def) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(v_def[1]) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
+
+ v_empty[0] := 17; // not empty anymore
+ if ( isbound(v_empty[0]) ) { setverdict(pass); } else { setverdict(fail); };
+
+ template intreclist it1 := { { a := { 1, 2, 3 } } };
+ template intreclist it2 modifies it1 := { { a := { 1, 2, -, -, -, 100 } } };
+ template intrec itt1 := { a := { 1, 2, 3 } };
+ template intrec itt2 modifies itt1 := { a := { 1, 2, -, -, -, 100 } };
+ if (isbound (it1)) { setverdict(pass); } else { setverdict(fail); };
+ if (isbound (it2)) { setverdict(pass); } else { setverdict(fail); };
+ if (isbound (itt1)) { setverdict(pass); } else { setverdict(fail); };
+ if (isbound (itt2)) { setverdict(pass); } else { setverdict(fail); };
+
+ var threeD d3_emtpy;
+ const threeD d3 := {
+ {
+ { 1,2,3 },
+ { 1,2,3 },
+ { 1,2,3 }
+ },
+ {
+ { 1,2,3 },
+ { 1,2,3 },
+ { 1,2,3 }
+ },
+ {
+ { 1,2,3 },
+ { 1,2,3 },
+ { 1,2,3 }
+ }
+ }
+ var threeD nowhere := {
+ { {-,1,-},{-,1,-},{-,1,-} },
+ { {-,1,-},{-,-,-},{-,1,-} },
+ { {-,1,-},{-,1,-},{-,1,-} }
+ }
+
+ if ( isbound(d3_emtpy) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(d3_emtpy[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(d3_emtpy[0][1]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(d3_emtpy[0][1][2]) ) { setverdict(fail); } else { setverdict(pass); };
+
+ if ( isbound(nowhere) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(nowhere[1]) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(nowhere[1][1]) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(nowhere[1][1][1]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(d3) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(d3[0]) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(d3[0][1]) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(d3[0][1][2]) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+testcase recofCompConst() runs on recofOper_mycomp{
+ const recofOper_myrecof1 c_r1 := { 1,2,3,4};
+ const recofOper_myrecof1 c_r2 := { 1,2,3,4};
+ const recofOper_myrecof1 c_r3 := { 4,3,2,1};
+ const recofOper_myrecof1 c_r4_ind := { [0] := 1, [1] := 2, [2] := 3, [3] := 4};
+ const recofOper_myrecof1 c_r5_ind := { [3] := 1, [1] := 2, [2] := 3, [0] := 4};
+ const recofOper_myrecof1 c_r6_ind := { [3] := 4, [1] := 2, [2] := 3, [0] := 1};
+ const recofOper_myrecof1 c_r8_ind := { [0] := 1, [1] := 2, [2] := 3, [3] := 4};
+
+
+ var recofOper_myrecof1 vl_r7_ind := { [3] := 4, [1] := 2};
+
+ var recofOper_myrecof1 vl_r10 := { 1,2,3,4};
+ var recofOper_myrecof1 vl_r11 := { 1,2,3,4};
+
+ if(c_r1 == c_r1) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_r1 == c_r2) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_r1 == c_r4_ind) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_r4_ind == c_r4_ind) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_r1 == c_r6_ind) {setverdict(pass);}
+ else {setverdict(fail);}
+
+
+ if(c_r1 != vl_r7_ind) {setverdict(pass);}
+ else { setverdict(fail);}
+
+ if(c_r4_ind == c_r8_ind) {setverdict(pass); }
+ else {setverdict(fail);}
+
+ if(vl_r10 == vl_r11) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+type record length(10) of integer MyRecordOfType10
+type record length(0..10) of integer MyRecordOfType0_10
+type record length(10..infinity) of integer MyRecordOfType10up
+type record length(0..10) of charstring StringArray length(12)
+type record of record of charstring StringArrayTwo length(12)
+type record of charstring MyRecof2 ("a", "aa", "aaa", "aaaa") length(2)
+type record length(2) of charstring MyRecof3 ("a", "aa", "aaa", "aaaa")
+type record length(2) of charstring MyRecof4 ("a", "aa", "aaa", "aaaa") length(2)
+// TODO: Add additional subtypes here.
+type MyRecof2 MyRecof5
+type MyRecof3 MyRecof6
+type MyRecof4 MyRecof7
+type MyRecof2 MyRecof8 ({"aa"})
+type record of integer MyRecof9 (1..10, 100)
+
+const MyRecof2 c_myrecof1 := {}
+const MyRecof2 c_myrecof2 := {"aa", "aa"}
+const MyRecof2 c_myrecof3 := {c_myrecof2[0], c_myrecof2[1]}
+const MyRecof3 c_myrecof4 := {"a", "aa"}
+const MyRecof3 c_myrecof5 := {c_myrecof4[0], c_myrecof4[1]}
+const MyRecof4 c_myrecof6 := {"aa", "aa"}
+const MyRecof4 c_myrecof7 := {c_myrecof6[0], c_myrecof6[1]}
+const MyRecof8 c_myrecof8 := {"aa"}
+const MyRecof9 c_myrecof9 := {1, 100}
+
+template MyRecof2 t_myrecof1 := {}
+template MyRecof2 t_myrecof2 := {"aa", "aa"}
+template MyRecof2 t_myrecof3 := c_myrecof2
+template MyRecof3 t_myrecof4 := {"a", "aa"}
+template MyRecof3 t_myrecof5 := c_myrecof5
+template MyRecof4 t_myrecof6 := {"aa", "aa"}
+template MyRecof4 t_myrecof7 := c_myrecof7
+template MyRecof8 t_myrecof8 := {"aa"}
+template MyRecof9 t_myrecof9 := {1, 100} length(2)
+
+testcase recofSubtype() runs on recofOper_mycomp {
+ var template MyRecordOfType10 vt_myrecof1 := { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+ var MyRecordOfType10 v_myrecof1 := { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
+ if (substr(v_myrecof1, 0, 2) == substr(vt_myrecof1, 1, 2)) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+type record of charstring ROC;
+type record of integer ROI;
+type record MyRecord1 {
+ integer i optional,
+ float x optional,
+ charstring c
+}
+
+type record of ROI ROROI;
+
+type union MyUnion1 {
+ ROC roc,
+ integer i,
+ ROI roi,
+ MyRecord1 r
+}
+
+type record MyRec2 {
+ ROC roc optional,
+ ROI roi optional,
+ MyUnion1 u optional,
+ MyRecord1 r optional
+}
+
+type record of MyRec2 MyRecOf
+
+type record MyRec3 {
+ ROROI roroi optional,
+ MyRec2 r optional
+}
+
+const MyRec2 c_myrec2_1:={
+ roc:=omit,
+ roi:={},
+ u:={r:={ i:=1, x:=1.0, c:="one"}},
+ r:={ i:=1, x:=1.0, c:="one"}
+}
+
+const MyRec3 c_myrec3_1 := {
+ roroi:= { {1,2,3,4,5,6,7,8,9},{10} },
+ r:= omit
+}
+
+const MyRec3 c_myrec3_2 := {
+ roroi:= { {1,2,3,4,5,6,7,8,9},{10} },
+ r:= {
+ roc:={},
+ roi:={},
+ u:={i:=5},
+ r:=omit
+ }
+}
+
+const MyRec3 c_myrec3_innerOmits := {
+ roroi:= { {1,2,3,4,5,6,7,8,9},{10} },
+ r:= {
+ roc:=omit,
+ roi:=omit,
+ u:=omit,
+ r:=omit
+ }
+}
+
+testcase tc_recordOf_omit1() runs on recofOper_mycomp {
+ var MyRec2 vl_r1:=c_myrec2_1;
+ if(isbound(vl_r1.roc)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2 vl_r2:=c_myrec2_1;
+ if(isbound(vl_r2.roc[0])){setverdict(fail)}else {setverdict(pass)};
+ var MyRec2 vl_r3:=c_myrec2_1;
+ if(isbound(vl_r3.roi)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2 vl_r4:=c_myrec2_1;
+ if(isbound(vl_r4.roi[0])){setverdict(fail)}else {setverdict(pass)};
+ var MyRec2 vl_r5:=c_myrec2_1;
+ if(isbound(vl_r5.roi[90])){setverdict(fail)}else {setverdict(pass)};
+}
+
+testcase tc_recordOf_union() runs on recofOper_mycomp {
+ var MyRec2 vl_r:=c_myrec2_1;
+ if(isbound(vl_r.u)){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.u.r)){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.u.r.i)){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.u.r.x)){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.u.r.c)){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.u.roi)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vl_r.u.roi[3])){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vl_r.u.i)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vl_r.u.roc)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vl_r.u.roc[0])){setverdict(fail)}else {setverdict(pass)};
+}
+
+testcase tc_recordOf_recordOfRecordOfInt() runs on recofOper_mycomp {
+ var MyRec3 vl_r:=c_myrec3_1;
+ if(isbound(vl_r.roroi)){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.roroi[0])){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.roroi[1])){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.roroi[2])){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vl_r.roroi[200])){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vl_r.roroi[0][0])){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.roroi[0][8])){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.roroi[0][9])){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vl_r.roroi[1][0])){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.roroi[1][1])){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vl_r.roroi[2][0])){setverdict(fail)}else {setverdict(pass)};
+}
+
+testcase tc_recordOf_recordInRecord() runs on recofOper_mycomp {
+ var MyRec3 vl_r:=c_myrec3_2;
+ if(isbound(vl_r.r)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r.roc)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r.roi)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r.u)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r.u)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r.u.i)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r.r)) {setverdict(pass)}else {setverdict(fail)}; //fails!
+}
+
+testcase tc_recordOf_recordInRecord_innerOmits() runs on recofOper_mycomp {
+ var MyRec3 vl_r:=c_myrec3_innerOmits;
+ if(isbound(vl_r.roroi)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r.roc)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r.roi)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r.u)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r.r)){setverdict(pass)}else {setverdict(fail)};
+}
+
+ testcase tc_recordOf_union_ispresent() runs on recofOper_mycomp {
+ var MyRec2 vl_r:=c_myrec2_1;
+ if(ispresent(vl_r.u)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.u.r)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.u.r.i)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.u.r.x)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.u.r.c)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.u.roi)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u.roi[3])){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u.i)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u.roc)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u.roc[0])){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_recordOf_recordOfRecordOfInt_ispresent() runs on recofOper_mycomp {
+ var MyRec3 vl_r:=c_myrec3_1;
+ if(ispresent(vl_r.roroi)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.roroi[0])){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.roroi[1])){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.roroi[2])){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.roroi[200])){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.roroi[0][0])){setverdict(pass)}else {setverdict(fail)};
+ }
+
+ testcase tc_recordOf_recordOfRecordOfInt2() runs on recofOper_mycomp {
+ var MyRec3 vl_r:=c_myrec3_1;
+ if(ispresent(vl_r.roroi[0][8])){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.roroi[0][9])){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.roroi[1][0])){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.roroi[1][1])){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.roroi[2][0])){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_recordOf_recordInRecord_ispresent() runs on recofOper_mycomp {
+ var MyRec3 vl_r:=c_myrec3_2;
+ if(ispresent(vl_r.r)) {setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.r.roc)) {setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.r.roi)) {setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.r.u)) {setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.r.u)) {setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.r.u.i)) {setverdict(pass)}else {setverdict(fail)};
+ }
+
+ testcase tc_recordOf_recordInRecord2() runs on recofOper_mycomp {
+ var MyRec3 vl_r:=c_myrec3_2;
+ if(ispresent(vl_r.r.r)) {setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_recordOf_recordInRecord_innerOmits_ispresent() runs on recofOper_mycomp {
+ var MyRec3 vl_r:=c_myrec3_innerOmits;
+ if(ispresent(vl_r.roroi)) {setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.r)) {setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.r.roc)) {setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.r.roi)) {setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.r.u)) {setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.r.r)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+type record length(6) of integer MyArray6;
+
+//TR: HO84027
+testcase tc_sizeof_lengthof_roi_bugs() runs on recofOper_mycomp {
+ var template ROI vlt_roi :={}
+ var integer vl_array[6];
+ var MyArray6 vl_array6;
+ var template MyArray6 vlt_array6;
+
+ vlt_roi[0]:=0;
+ vlt_roi[5]:=0;
+
+ vl_array[0]:=0;
+ vl_array[4]:=0;
+
+ vl_array6[0]:=0;
+ vl_array6[4]:=0;
+
+ vlt_array6[0]:=0;
+ vlt_array6[4]:=0;
+
+ if(sizeof(vlt_roi)==6) { setverdict(pass) } else { setverdict(fail) };
+ if(lengthof(vlt_roi)==6) { setverdict(pass) } else { setverdict(fail) };
+
+ if(sizeof(vl_array)==6) { setverdict(pass) } else { setverdict(fail) };
+ if(lengthof(vl_array)==5) { setverdict(pass) } else { setverdict(fail) };
+
+ if(sizeof(vl_array6)==5) { setverdict(pass) } else { setverdict(fail) };
+ if(lengthof(vl_array6)==5) { setverdict(pass) } else { setverdict(fail) };
+
+ if(sizeof(vlt_array6)==5) { setverdict(pass) } else { setverdict(fail) };
+ if(lengthof(vlt_array6)==5){ setverdict(pass) } else { setverdict(fail) };
+}
+
+//testcase tc_sizeof_lengthof_standard1() runs on recofOper_mycomp {
+// if(lengthof(bitstring : '010'B) == 3) { setverdict(pass)} else { setverdict(fail) };
+// if(lengthof(hexstring : 'F3'H) == 2) { setverdict(pass)} else { setverdict(fail) };
+// if(lengthof(octetstring : 'F2'O) == 1) { setverdict(pass)} else { setverdict(fail) };
+// if(lengthof (universal charstring : "Length_of_Example")==17) { setverdict(pass)}else { setverdict(fail) };
+// if(lengthof(charstring : "HELLO") == 5) { setverdict(pass)}else { setverdict(fail) };
+// if(lengthof(octetstring : ('12'O, '34'O))==1){ setverdict(pass)}else { setverdict(fail) };
+// if(lengthof('1??1'B)==4){ setverdict(pass)}else { setverdict(fail) };
+// if(lengthof(universal charstring : ? length(8))==8 ) { setverdict(pass)}else { setverdict(fail) }; //DTE
+// if(lengthof('1*F'H length (8)) ==8){ setverdict(pass)}else { setverdict(fail) };
+//// if(lengthof('00*FF'O length(1..2))==2) { setverdict(pass)}else { setverdict(fail) };
+//}
+
+type record length(0..10) of integer MyList;
+
+testcase tc_sizeof_lengthof_standard2() runs on recofOper_mycomp {
+ var MyList vl_MyListVar := { 0, 1, -, 2, - };
+ log("vl_MyListVar: ",vl_MyListVar);
+ if(lengthof(vl_MyListVar)==4) { setverdict(pass)}else { setverdict(fail) };
+}
+
+testcase tc_sizeof_lengthof_standard4() runs on recofOper_mycomp {
+ template ROI tr_roI3 := { 1, *, 10 } length(5)
+ if(lengthof(tr_roI3)==5){ setverdict(pass)}else { setverdict(fail) };
+}
+
+testcase tc_sizeof_lengthof_standard6() runs on recofOper_mycomp {
+ template ROI tr_roI5 := { 1, 2, 3, * } length(1..3)
+ if(lengthof(tr_roI5)==3) { setverdict(pass)}else { setverdict(fail) };
+}
+
+// test cases for bug 494614:
+// when initializing a record-of-record element with an empty value ('{}') through module parameters,
+// an actual unbound record element was created, instead of the usual null pointer used for unbound elements;
+// copying this empty record caused a dynamic test case error
+
+//modulepar recofOper_myrecof3 recofOper_mymodulepar; // initialized with value list notation
+//modulepar recofOper_myrecof3 recofOper_mymodulepar2; // initialized with assignment notation
+
+//testcase tc_empty_record_element() runs on recofOper_mycomp {
+// var recofOper_myrecof3 copy := recofOper_mymodulepar;
+// copy[0].x1 := omit; // this is where the record-of is actually copied, and where the DTE occured
+// copy[0].x2 := 1.0;
+// if (copy == { { omit, 1.0 } }) { setverdict(pass); }
+// else { setverdict(fail); }
+//}
+//
+//testcase tc_empty_record_element2() runs on recofOper_mycomp {
+// var recofOper_myrecof3 copy := recofOper_mymodulepar2;
+// copy[0].x1 := omit; // this is where the record-of is actually copied, and where the DTE occured
+// copy[0].x2 := 1.0;
+// if (copy == { { omit, 1.0 } }) { setverdict(pass); }
+// else { setverdict(fail); }
+//}
+
+control {
+ const recofOper_trecord cl_temp1:={ x1:=omit, x2:=3.4 }; // constants in the control part
+ const recofOper_trecof cl_temp2:={ 'AF12'O };
+ const recofOper_tset cl_temp3:={ x1:=234, x2:=1.9};
+ const recofOper_tsetof cl_temp4:={"f","8"};
+ const recofOper_tunion cl_temp5:={ x2:=1.3 };
+ const recofOper_trecord vl_temp1:={ x1:=omit, x2:=3.4 }; // variables in the control part
+ const recofOper_trecof vl_temp2:={ 'AF12'O };
+ const recofOper_tset vl_temp3:={ x1:=234, x2:=1.9};
+ const recofOper_tsetof vl_temp4:={"f","8"};
+ const recofOper_tunion vl_temp5:={ x2:=1.3 };
+
+ execute(recofAssign());
+ execute(recofReAssign());
+ execute(recofAssignEnum());
+ execute(recofAssignRec());
+ execute(recofAssignRecof());
+ execute(recofAssignSet());
+ execute(recofAssignSetof());
+ execute(recofAssignUnion());
+ execute(recofAssignElem());
+ execute(recofAssignElemEnum());
+ execute(recofAssignElemRec());
+ execute(recofAssignElemRecof());
+ execute(recofAssignElemSet());
+ execute(recofAssignElemSetof());
+ execute(recofAssignElemUnion());
+ execute(recofConst());
+ execute(recofConstEnum());
+ execute(recofConstRec());
+ execute(recofConstRecof());
+ execute(recofConstSet());
+ execute(recofConstSetof());
+ execute(recofConstUnion());
+ execute(recofComp());
+ execute(recofCompConst());
+ execute(recofCompEnum());
+ execute(recofCompRec());
+ execute(recofCompRecof());
+ execute(recofCompSet());
+ execute(recofCompSetof());
+ execute(recofCompUnion());
+ execute(recofEmpty());
+
+ execute(recofListOperator());
+ execute(recofRotateOperators());
+ execute(recofLengthof());
+ execute(recofSizeof());
+ execute(recofReplace());
+ execute(recofReplaceEmpty());
+ execute(recofSubstr());
+ execute(recofIsvalue());
+ execute(recofIsvalue2());
+ execute(recofIsbound());
+
+ execute(recofSubtype());
+
+ execute(tc_recordOf_omit1());
+ execute(tc_recordOf_union());
+ execute(tc_recordOf_recordOfRecordOfInt());
+ execute(tc_recordOf_recordInRecord());
+ execute(tc_recordOf_recordInRecord_innerOmits());
+ execute(tc_recordOf_union_ispresent());
+ execute(tc_recordOf_recordOfRecordOfInt_ispresent());
+ execute(tc_recordOf_recordOfRecordOfInt2());
+ execute(tc_recordOf_recordInRecord_ispresent());
+ execute(tc_recordOf_recordInRecord2());
+ execute(tc_recordOf_recordInRecord_innerOmits_ispresent());
+ execute(tc_sizeof_lengthof_roi_bugs());
+// execute(tc_sizeof_lengthof_standard1());
+ execute(tc_sizeof_lengthof_standard2());
+ execute(tc_sizeof_lengthof_standard4());
+ execute(tc_sizeof_lengthof_standard6());
+
+// execute(tc_empty_record_element());
+// execute(tc_empty_record_element2());
+}
+
+}
diff --git a/Regression_Test_java/src/TrecordOper.ttcn b/Regression_Test_java/src/TrecordOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..0ebc838203c4598dad7efddfd674a0904dfbf093
--- /dev/null
+++ b/Regression_Test_java/src/TrecordOper.ttcn
@@ -0,0 +1,2405 @@
+/******************************************************************************
+ * 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
+ * Beres, Szabolcs
+ * Kovacs, Ferenc
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TrecordOper {
+// ********** Type definitions *********************
+type component recordOper_mycomp {};
+type enumerated recordOper_myenum {xx1,xx2,xx3};
+type record recordOper_empty {};
+type record recordOper_trecord {
+ integer x1 optional,
+ float x2 };
+type record of octetstring recordOper_trecof;
+type set recordOper_tset {
+ integer x1,
+ float x2 optional };
+type set of charstring recordOper_tsetof;
+type union recordOper_tunion {
+ integer x1,
+ float x2 };
+type record recordOper_myrec1 { // record from basic types
+ integer x1,
+ float x2,
+ recordOper_myenum x3 };
+type record recordOper_myrec2 { // record from basic types, with optional field
+ integer x1,
+ float x2,
+ recordOper_myenum x3,
+ integer x4 optional };
+type record recordOper_myrec3 { // record from record, with optional field
+ recordOper_trecord x1,
+ recordOper_trecord x2 optional
+ };
+type record recordOper_myrec4 { // record from record of, with optional field
+ recordOper_trecof x1,
+ recordOper_trecof x2 optional
+ };
+type record recordOper_myrec5 { // record from set, with optional field
+ recordOper_tset x1,
+ recordOper_tset x2 optional
+ };
+type record recordOper_myrec6 { // record from set of, with optional field
+ recordOper_tsetof x1,
+ recordOper_tsetof x2 optional
+ };
+type record recordOper_myrec7 { // record from union, with optional field
+ recordOper_tunion x1,
+ recordOper_tunion x2 optional
+ };
+type record typedefrecordComp_myrec { // testing complex content
+ recordOper_trecord x1,
+ recordOper_trecof x2,
+ recordOper_tset x3,
+ recordOper_tsetof x4 optional,
+ recordOper_tunion x5,
+ integer x6[3]
+};
+type record recordOper_myrec8{
+ integer f1 optional,
+ charstring f2 optional
+ };
+type record recordOper_myrec9 { // test for the assignment of optional fields
+ integer f1 optional,
+ integer f2 optional
+};
+// *************** Constanst ***********************
+const recordOper_trecord recordOper_temp1:={ x1:=omit, x2:=3.4 };
+const recordOper_trecof recordOper_temp2:={ 'AF12'O };
+const recordOper_tset recordOper_temp3:={ x1:=234, x2:=1.9};
+const recordOper_tsetof recordOper_temp4:={"f","8"};
+const recordOper_tunion recordOper_temp5:={ x2:=1.3 };
+const recordOper_myrec1 recordOper_const1:={ //record with basic types
+x1:=1,
+x2:=1.2,
+x3:=xx2 };
+const recordOper_myrec2 recordOper_const2:={ //record with basic types, with optional field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=2 };
+const recordOper_myrec2 recordOper_const3:={ //record with basic types, with omited field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=omit };
+const recordOper_myrec3 recordOper_const4:={ //record from record
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=recordOper_temp1
+};
+const recordOper_myrec3 recordOper_const5:={ //record from record, with omited field
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=omit
+};
+const recordOper_myrec4 recordOper_const6:={ //record from record of
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=recordOper_temp2
+};
+const recordOper_myrec4 recordOper_const7:={ //record from record of, with omited field
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=omit
+};
+const recordOper_myrec5 recordOper_const8:={ //record from set
+ x1:={ x1:=2, x2:=1.3},
+ x2:=recordOper_temp3
+};
+const recordOper_myrec5 recordOper_const9:={ //record from set, with omited field
+ x1:={ x1:=2, x2:=1.3},
+ x2:=omit
+};
+const recordOper_myrec6 recordOper_const10:={ //record from set of
+ x1:={"a","b"},
+ x2:=recordOper_temp4 //{"f","8"},
+};
+const recordOper_myrec6 recordOper_const11:={ //record from set of, with omited field
+ x1:={"a","b"},
+ x2:=omit
+};
+const recordOper_myrec7 recordOper_const12:={ //record from union
+ x1:={ x1 :=3 },
+ x2:=recordOper_temp5 //{ x2:=1.3 }
+};
+const recordOper_myrec7 recordOper_const13:={ //record from union, with omited field
+ x1:={ x1 :=3 },
+ x2:=omit
+};
+const typedefrecordComp_myrec recordOper_const14 := { // complex record
+ x1 := { x1:=omit, x2:=3.4 },
+ x2 := { 'AF12'O },
+ x3 := { x1:=234, x2:=1.9},
+ x4 := {"f","8"},
+ x5 := { x2:=1.3 },
+ x6 := {1,2,3}
+}
+
+testcase recordAssign() runs on recordOper_mycomp{
+var recordOper_myrec1 x1:={ //record with basic types
+x1:=1,
+x2:=1.2,
+x3:=xx2 };
+var recordOper_myrec1 x2;
+ x2:={ x1:=1, x2:=1.2, x3:=xx2 };
+var recordOper_myrec1 x3 := {};
+if (x1.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+// test some incomplete assignment cases.
+testcase recordAssignIncomplete() runs on recordOper_mycomp{
+var recordOper_myrec1 x1:={ x1:=1, x2:=1.2};
+ if(x1.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not(isbound(x1.x3))) {setverdict(pass);}
+ else {setverdict(fail);}
+
+x1 := {2, -, -};
+ if(x1.x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not(isbound(x1.x3))) {setverdict(pass);}
+ else {setverdict(fail);}
+
+x1:= { x1 := -, x2:=2.2, x3 := -};
+ if(x1.x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(x1.x2==2.2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not(isbound(x1.x3))) {setverdict(pass);}
+ else {setverdict(fail);}
+
+x1:= { x2:=3.2};
+ if(x1.x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(x1.x2==3.2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not(isbound(x1.x3))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordAssignOpt() runs on recordOper_mycomp{
+var integer inttemp:=2;
+var recordOper_myrec2 x1:={ //record with basic types, with optional field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=inttemp}; //2
+var recordOper_myrec2 x2:={ //record with basic types, with omited field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=omit };
+var recordOper_myrec2 x3, x4;
+x3:={ //record with basic types, with optional field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=inttemp }; //2
+x4:={ //record with basic types, with omited field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=omit };
+//at declaration, with optional field
+if (x1.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x4==2) {setverdict(pass);}
+ else {setverdict(fail);}
+//at declaration, with omited field
+if (x2.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2.x4))) {setverdict(pass);}
+ else {setverdict(fail);}
+//later, with optional field
+if (x3.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x4==2) {setverdict(pass);}
+ else {setverdict(fail);}
+//later, with optional field
+if (x4.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x4))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordAssignRec() runs on recordOper_mycomp{
+var recordOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var recordOper_myrec3 x1:={ //record from record
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+var recordOper_myrec3 x2:={ //record from record, with omited field
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=omit
+};
+var recordOper_myrec3 x3,x4;
+x3:={ //record from record
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x4:={ //record from record, with omited field
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=omit
+};
+if (x1.x1.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x1==1) {setverdict(pass);} //at declaration, omit
+ else {setverdict(fail);}
+if (x2.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x1.x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x3.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x1.x1==1) {setverdict(pass);} //later, omit
+ else {setverdict(fail);}
+if (x4.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordAssignRecof() runs on recordOper_mycomp{
+var recordOper_trecof temp2:={'AF12'O};
+var recordOper_myrec4 x1:={ //record from record of
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=temp2
+};
+var recordOper_myrec4 x2:={ //record from record of, with omited field
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=omit
+};
+var recordOper_myrec4 x3,x4
+x3:={ //record from record of
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=temp2
+};
+x4:={ //record from record of, with omited field
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=omit
+};
+if (x1.x1[0]=='12AB'O) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1[0]=='12AB'O) {setverdict(pass);} //at declaration, omit
+ else {setverdict(fail);}
+if (x2.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x1[0]=='12AB'O) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x3.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x1[0]=='12AB'O) {setverdict(pass);} //later, omit
+ else {setverdict(fail);}
+if (x4.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordAssignSet() runs on recordOper_mycomp{
+var recordOper_tset temp1:={ x1:=2, x2:=omit };
+var recordOper_myrec5 x1:={ //record from set
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+var recordOper_myrec5 x2:={ //record from set, with omited field
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=omit
+};
+var recordOper_myrec5 x3,x4;
+x3:={ //record from set
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x4:={ //record from set, with omited field
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=omit
+};
+if (x1.x1.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x1==1) {setverdict(pass);} //at declaration, omit
+ else {setverdict(fail);}
+if (x2.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x1.x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x3.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x1.x1==1) {setverdict(pass);} //later, omit
+ else {setverdict(fail);}
+if (x4.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordAssignSetof() runs on recordOper_mycomp{
+var recordOper_tsetof temp2:={"a","7"};
+var recordOper_myrec6 x1:={ //record from set of
+ x1:={ "1", "a" },
+ x2:=temp2
+};
+var recordOper_myrec6 x2:={ //record from set of, with omited field
+ x1:={ "1", "a" },
+ x2:=omit
+};
+var recordOper_myrec6 x3,x4
+x3:={ //record from set of
+ x1:={ "1", "a" },
+ x2:=temp2
+};
+x4:={ //record from set of, with omited field
+ x1:={ "1","a" },
+ x2:=omit
+};
+if (x1.x1[0]=="1") {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1[0]=="1") {setverdict(pass);} //at declaration, omit
+ else {setverdict(fail);}
+if (x2.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x1[0]=="1") {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x3.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x1[0]=="1") {setverdict(pass);} //later, omit
+ else {setverdict(fail);}
+if (x4.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordAssignUnion() runs on recordOper_mycomp{
+var recordOper_tunion temp5 := {x2:=1.3}
+var recordOper_myrec7 x1:={ //record from union
+ x1:={ x1 :=3 },
+ x2:=temp5 //{ x2:=1.3 }
+};
+var recordOper_myrec7 x2:={ //record from union, with omited field
+ x1:={ x1 :=3 },
+ x2:=omit
+};
+var recordOper_myrec7 x3,x4;
+x3:={ //record from union
+ x1:={ x1 :=3 },
+ x2:=temp5 //{ x2:=1.3 }
+};
+x4:={ //record from union, with omited field
+ x1:={ x1 :=3 },
+ x2:=omit
+};
+if (x1.x1.x1==3) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (ischosen(x1.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x1==3) {setverdict(pass);} //at declaration, omit
+ else {setverdict(fail);}
+if (ischosen(x2.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x1.x1==3) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (ischosen(x3.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x3.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x1.x1==3) {setverdict(pass);} //later, omit
+ else {setverdict(fail);}
+if (ischosen(x4.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x4.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordAssignElem() runs on recordOper_mycomp{
+var recordOper_myrec1 x1:={ //record with basic types
+x1:=1,
+x2:=1.2,
+x3:=xx2 };
+x1.x2:=3.4;
+if (x1.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase recordAssignElemOpt() runs on recordOper_mycomp{
+var integer inttemp:=2;
+var recordOper_myrec2 x1:={ //record with basic types
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=omit } ; //2
+var recordOper_myrec2 x2, x3, x4;
+x2:=x1;
+x3:={x1:=1, x2:=1.2, x3:=xx2, x4:=inttemp };
+x4:=x2;
+x1.x1:=2; //not optional field
+x2.x4:=3; //optional field; omited-> value
+x3.x4:=3; //optional field; value-> value
+x4.x4:=omit; //optional field; value -> omited
+//change not optional field
+if (x1.x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x1.x4))) {setverdict(pass);}
+ else {setverdict(fail);}
+//omited -> value
+if (x2.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x4==3) {setverdict(pass);}
+ else {setverdict(fail);}
+//optional field; value-> value
+if (x3.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x4==3) {setverdict(pass);}
+ else {setverdict(fail);}
+//optional field; value -> omited
+if (x4.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x4))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordAssignElemRec() runs on recordOper_mycomp{
+var recordOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var recordOper_myrec3 x1;
+x1:={ //record from record
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x1.x1.x1:=2;
+//temp1.x1:=3;
+//x1.x2:=temp1;
+if (x1.x1.x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase recordAssignElemRecof() runs on recordOper_mycomp{
+var recordOper_trecof temp2:={'AF12'O};
+var recordOper_myrec4 x1:={ //record from record of
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=temp2
+};
+x1.x1[1]:='34AB'O;
+if (x1.x1[0]=='12AB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x1[1]=='34AB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordAssignElemSet() runs on recordOper_mycomp{
+var recordOper_tset temp1:={ x1:=2, x2:=omit };
+var recordOper_myrec5 x1:={ //record from set
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x1.x1.x2:=3.4;
+if (x1.x1.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x1.x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordAssignElemSetof() runs on recordOper_mycomp{
+var recordOper_tsetof temp2:={"a","7"};
+var recordOper_myrec6 x1:={ //record from set of
+ x1:={ "1", "a" },
+ x2:=temp2
+};
+x1.x1[0]:="h";
+if (x1.x1[0]=="h") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordAssignElemUnion() runs on recordOper_mycomp{
+var recordOper_tunion temp5 := {x2:=1.3}
+var recordOper_myrec7 x1:={ //record from union
+ x1:={ x1 :=3 },
+ x2:=temp5 //{ x2:=1.3 }
+};
+x1.x1.x2:=3.4;
+if (x1.x1.x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x1.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordSizeof() runs on recordOper_mycomp{
+var integer inttemp:=2;
+var recordOper_myrec2 x1:={ //record with basic types, with optional field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=inttemp}; //2
+var recordOper_myrec2 x2:={ //record with basic types, with omited field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=omit };
+var recordOper_myrec2 x3, x4;
+x3:={ //record with basic types, with optional field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=inttemp }; //2
+x4:={ //record with basic types, with omited field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=omit };
+var recordOper_myrec4 x5;
+x5.x1 := { '12AB'O, '12AB'O};
+x5.x2 := { '12AB'O, '12AB'O, '12AB'O};
+if (sizeof(x1)==4) {setverdict(pass);} //at declaration, with optional field
+ else {setverdict(fail);}
+if (sizeof(x2)==3) {setverdict(pass);} //at declaration, with omited field
+ else {setverdict(fail);}
+if (sizeof(x3)==4) {setverdict(pass);} //later, with optional field
+ else {setverdict(fail);}
+if (sizeof(x4)==3) {setverdict(pass);} //testcase, with optional field
+ else {setverdict(fail);}
+if (sizeof(x5.x1)==2 and sizeof(x5.x2) == 3) {setverdict(pass);} //testcase, with optional field
+ else {setverdict(fail);}
+}
+
+testcase recordConst() runs on recordOper_mycomp{
+const recordOper_myrec1 const1:={ //record with basic types
+x1:=1,
+x2:=1.2,
+x3:=xx2 };
+if (recordOper_const1.x1==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (recordOper_const1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const1.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1.x1==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordConstOpt() runs on recordOper_mycomp{
+const recordOper_myrec2 const2:={ //record with basic types, with optional field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=2 };
+const recordOper_myrec2 const3:={ //record with basic types, with omited field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=omit };
+//definition part, with optional field
+if (recordOper_const2.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const2.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const2.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const2.x4==2) {setverdict(pass);}
+ else {setverdict(fail);}
+//definition part, with omited field
+if (recordOper_const3.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const3.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const3.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(recordOper_const3.x4))) {setverdict(pass);}
+ else {setverdict(fail);}
+//testcase, with optional field
+if (const2.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const2.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const2.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const2.x4==2) {setverdict(pass);}
+ else {setverdict(fail);}
+//testcase, with omited field
+if (const3.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const3.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const3.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(const3.x4))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordConstRec() runs on recordOper_mycomp{
+const recordOper_myrec3 const4:={ //record from record
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=recordOper_temp1
+};
+const recordOper_myrec3 const5:={ //record from record, with omited field
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=omit
+};
+if (recordOper_const4.x1.x1==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (recordOper_const4.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const4.x2==recordOper_temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const5.x1.x1==1) {setverdict(pass);} //definition part, omit
+ else {setverdict(fail);}
+if (recordOper_const5.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(recordOper_const5.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const4.x1.x1==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const4.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const4.x2==recordOper_temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const5.x1.x1==1) {setverdict(pass);} //testcase, omit
+ else {setverdict(fail);}
+if (const5.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(const5.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordConstRecof() runs on recordOper_mycomp{
+const recordOper_myrec4 const6:={ //record from record of
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=recordOper_temp2
+};
+const recordOper_myrec4 const7:={ //record from record of, with omited field
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=omit
+};
+if (recordOper_const6.x1[0]=='12AB'O) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (recordOper_const6.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const6.x2==recordOper_temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const7.x1[0]=='12AB'O) {setverdict(pass);} //definition part, omit
+ else {setverdict(fail);}
+if (recordOper_const7.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(recordOper_const7.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const6.x1[0]=='12AB'O) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const6.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const6.x2==recordOper_temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const7.x1[0]=='12AB'O) {setverdict(pass);} //testcase, omit
+ else {setverdict(fail);}
+if (const7.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(const7.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordConstSet() runs on recordOper_mycomp{
+const recordOper_myrec5 const8:={ //record from set
+ x1:={ x1:=2, x2:=1.3},
+ x2:=recordOper_temp3
+};
+const recordOper_myrec5 const9:={ //record from set, with omited field
+ x1:={ x1:=2, x2:=omit},
+ x2:=omit
+};
+if (recordOper_const8.x1.x1==2) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (recordOper_const8.x1.x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const8.x2==recordOper_temp3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const9.x1.x1==2) {setverdict(pass);} //definition part, omit
+ else {setverdict(fail);}
+if (recordOper_const9.x1.x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(recordOper_const9.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const8.x1.x1==2) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const8.x1.x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const8.x2==recordOper_temp3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const9.x1.x1==2) {setverdict(pass);} //testcase, omit
+ else {setverdict(fail);}
+if (not(ispresent(const9.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(const9.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordConstSetof() runs on recordOper_mycomp{
+const recordOper_myrec6 const10:={ //record from set of
+ x1:={"a","b"},
+ x2:=recordOper_temp4 //{"f","8"},
+};
+const recordOper_myrec6 const11:={ //record from set of, with omited field
+ x1:={"a","b"},
+ x2:=omit
+};
+if (recordOper_const10.x1[0]=="a") {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (recordOper_const10.x1[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const10.x2==recordOper_temp4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const11.x1[0]=="a") {setverdict(pass);} //definition part, omit
+ else {setverdict(fail);}
+if (recordOper_const11.x1[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(recordOper_const11.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const10.x1[0]=="a") {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const10.x1[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (const10.x2==recordOper_temp4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const11.x1[0]=="a") {setverdict(pass);} //testcase, omit
+ else {setverdict(fail);}
+if (const11.x1[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(const11.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordConstUnion() runs on recordOper_mycomp{
+const recordOper_myrec7 const12:={ //record from union
+ x1:={ x1 :=3 },
+ x2:=recordOper_temp5 //{ x2:=1.3 }
+};
+const recordOper_myrec7 const13:={ //record from union, with omited field
+ x1:={ x1 :=3 },
+ x2:=omit
+};
+if (recordOper_const12.x1.x1==3) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (ischosen(recordOper_const12.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(recordOper_const12.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const12.x2==recordOper_temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+if (recordOper_const13.x1.x1==3) {setverdict(pass);} //definition part, omit
+ else {setverdict(fail);}
+if (ischosen(recordOper_const13.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(recordOper_const13.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(recordOper_const13.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const12.x1.x1==3) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (ischosen(const12.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const12.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const12.x2==recordOper_temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const13.x1.x1==3) {setverdict(pass);} //testcase, omit
+ else {setverdict(fail);}
+if (ischosen(const13.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const13.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(const13.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordComp() runs on recordOper_mycomp{
+var recordOper_myrec1 x1,x2,x3; // record with basic types
+x1:={ x1:=1, x2:=1.2, x3:=xx2 };
+x2:={ x1:=1, x2:=1.2, x3:=xx2 };
+x3:={ x1:=1, x2:=1.24, x3:=xx2 }
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase recordCompOpt() runs on recordOper_mycomp{
+var integer inttemp:=2; // record with basic types and optional field
+var recordOper_myrec2 x1,x2,x3;
+x1 :={ x1:=1, x2:=1.2, x3:=xx2, x4:=inttemp }; //inntemp=2
+x2:= { x1:=1, x2:=1.2, x3:=xx2, x4:=omit };
+x3:= { x1:=1, x2:=1.2, x3:=xx2, x4:=omit };
+if (x2==x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x2!=x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordCompOptField() runs on recordOper_mycomp
+{
+ const recordOper_trecord c1 := { x1 := omit, x2 := 0.0 };
+ const recordOper_trecord c2 := { x1 := 1, x2 := 0.0 };
+ const integer ci := 1;
+ var recordOper_trecord v := { x1 := omit };
+ var integer i := 1;
+ if (c1.x1 == omit and c1.x1 != 1 and /*c1.x1 != i and*/ c1.x1 != ci and c1.x1 == c1.x1 and
+ omit == c1.x1 and 1 != c1.x1 and /*i != c1.x1 and*/ ci != c1.x1 and not c1.x1 != c1.x1)
+ { setverdict(pass); }
+ else { setverdict(fail); }
+ if (c2.x1 != omit and c2.x1 == 1 and c2.x1 == i and c2.x1 == ci and c2.x1 == c2.x1 and
+ omit != c2.x1 and 1 == c2.x1 and i == c2.x1 and ci == c2.x1 and not c2.x1 != c2.x1)
+ { setverdict(pass); }
+ else { setverdict(fail); }
+ if (v.x1 == omit and v.x1 != 1 and v.x1 != i and v.x1 == v.x1 and
+ omit == v.x1 and 1 != v.x1 and i != v.x1 and not v.x1 != v.x1)
+ { setverdict(pass); }
+ else { setverdict(fail); }
+ v.x1 := 1;
+ if (v.x1 != omit and v.x1 == 1 and v.x1 == i and v.x1 == v.x1 and
+ omit != v.x1 and 1 == v.x1 and i == v.x1 and not v.x1 != v.x1)
+ { setverdict(pass); }
+ else { setverdict(fail); }
+}
+
+testcase recordCompRec() runs on recordOper_mycomp{
+var recordOper_trecord temp1:={ x1:=omit, x2:=3.4 }; // record with record
+var recordOper_myrec3 x1,x2,x3;
+x1 :={
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x2 :={
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x3 :={
+ x1:={ x1:=2, x2:=1.2 },
+ x2:=temp1
+};
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase recordCompRecof() runs on recordOper_mycomp{
+var recordOper_trecof temp2:={'AF12'O};
+var recordOper_myrec4 x1,x2,x3;
+x1:={ //record from record of
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=temp2
+};
+x2:={ //record from record of
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=temp2
+};
+x3:={ //record from record of
+ x1:={ '12AB'O },
+ x2:=temp2
+};
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordCompSet() runs on recordOper_mycomp{
+var recordOper_tset temp1:={ x1:=2, x2:=omit };
+var recordOper_myrec5 x1,x2,x3; //record from set
+x1:={
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x2:={
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x3:={
+ x1:={ x1:=4, x2:=1.2 },
+ x2:=temp1
+};
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x2==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordCompSetof() runs on recordOper_mycomp{
+var recordOper_tsetof temp2:={"a","7"};
+var recordOper_myrec6 x1,x2,x3; //record from set of
+x1:={
+ x1:={ "1", "a" },
+ x2:=temp2
+};
+x2:={
+ x1:={ "1", "a" },
+ x2:=temp2
+};
+x3:={
+ x1:={ "1", "a", "k" },
+ x2:=temp2
+};
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x2==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase recordCompUnion() runs on recordOper_mycomp{
+var recordOper_tunion temp5 := {x2:=1.3}; //record from union
+var recordOper_myrec7 x1,x2,x3;
+x1:={
+ x1:={ x1 :=3 },
+ x2:=temp5 //{ x2:=1.3 }
+};
+x2:={
+ x1:={ x1 :=3 },
+ x2:=temp5 //{ x2:=1.3 }
+};
+x3:={
+ x1:={ x2 :=3.9 },
+ x2:=temp5 //{ x2:=1.3 }
+};
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+// Example from CR 5262. No need to list all fields explicitly in the further
+// restricted type: `type myrecr1 myrecr2 ({ "", "" }, { "", "" })'.
+type record myrec1 {
+ integer f1 (0..255),
+ charstring f2,
+ charstring f3 optional
+}
+type myrec1 myrec2 ({1, "", ""}, {2, "", ""}, {f1 := 3, f2 := "", f3 := omit})
+type record MyRecordTypeWithSubtypedFields {
+ integer field1 (1..100),
+ charstring field2 length(2..255)
+}
+type myrec1 myrec3 (myrec2, {1, "", ""})
+
+const myrec2 c_myrec1 := {1, "", ""}
+
+template myrec2 t_myrec1 := c_myrec1
+
+function f_rec1() return MyRecordTypeWithSubtypedFields {
+ return { 2, "aaa" }
+}
+
+testcase recordSubtypes() runs on recordOper_mycomp {
+ var template MyRecordTypeWithSubtypedFields vt_myrec1 := {100, "hello"}
+ var MyRecordTypeWithSubtypedFields v_myrec1 := {field1 := 100, field2 := "hello"}
+ var myrec2 v_myrec2 := valueof(modifies t_myrec1 := {f1 := 2})
+ if (match(valueof(v_myrec1), vt_myrec1)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if ({ 2, "aaa" } == f_rec1() and f_rec1() == { 2, "aaa" }) { setverdict(pass) }
+ else { setverdict(fail) }
+ // FATAL_ERROR() with R8B: `if (valueof(MyRecordTypeWithSubtypedFields:{ 1, "hello" }) == valueof(v_myrec1)) { setverdict(pass) }'.
+}
+
+testcase recordIsvalue() runs on recordOper_mycomp{
+ var recordOper_empty v1;
+ var recordOper_trecord vs2_def;
+ var recordOper_trecord v2;
+ v2.x1 := 42;
+
+ if ( isvalue(v1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(vs2_def) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v2) ) { setverdict(fail); } else { setverdict(pass); };
+
+ var recordOper_trecord vs2_part := { -, 1.0 };
+ if ( isvalue(vs2_part) ) { setverdict(fail); } else { setverdict(pass); };
+ vs2_part.x1 := omit;
+ if ( isvalue(vs2_part) ) { setverdict(pass); } else { setverdict(fail); };
+
+ var recordOper_trecord vs2_om := { omit, - };
+ if ( isvalue(vs2_om) ) { setverdict(fail); } else { setverdict(pass); };
+ vs2_om.x2 := 33.0;
+ if ( isvalue(vs2_om) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+testcase recordIsbound() runs on recordOper_mycomp{
+ var recordOper_empty v1;
+ var recordOper_trecord vs2_def;
+ var recordOper_trecord v2;
+ v2.x1 := 42;
+
+ if ( isbound(v1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(vs2_def) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(vs2_def.x1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(vs2_def.x2) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(v2) ) { setverdict(pass); } else { setverdict(fail); };
+
+ var recordOper_trecord vs2_part := { -, 1.0 };
+ if ( isbound(vs2_part) ) { setverdict(pass); } else { setverdict(fail); };
+ vs2_part.x1 := omit;
+ if ( isbound(vs2_part) ) { setverdict(pass); } else { setverdict(fail); };
+
+ var recordOper_trecord vs2_om := { omit, - };
+ if ( isbound(vs2_om) ) { setverdict(pass); } else { setverdict(fail); };
+ vs2_om.x2 := 33.0;
+ if ( isbound(vs2_om) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+type set AllRec {
+ recordOper_myrec8 r1,
+ recordOper_myrec8 r2 optional
+}
+template recordOper_myrec8 t_MyRec := { f1 := *, f2 := * };
+const recordOper_myrec8 c1_MyRec := { f1 := 5, f2 := omit };
+const recordOper_myrec8 c2_MyRec := { f1 := omit, f2 := "omit" };
+const AllRec c_AllRec := { r1 := c1_MyRec, r2 := c2_MyRec }
+// This function is called from testcase recordIsvalue2
+function f_isvalue_record(in recordOper_myrec8 p1_MyRec, in recordOper_myrec8 p2_MyRec, in AllRec p_AllRec, in template recordOper_myrec8 pt_MyRec) runs on recordOper_mycomp
+{
+ var recordOper_myrec8 v1_MyRec;
+ var recordOper_myrec8 v2_MyRec;
+ var template recordOper_myrec8 vt_MyRec;
+ var AllRec v_AllRec;
+ template integer ti := 5 ifpresent;
+ template recordOper_myrec8 rrr1 := { 11, "true" }
+ template recordOper_myrec8 rrr2 := { 11, "true" } ifpresent;
+ template recordOper_myrec8 rrr3 := { 11, "true" ifpresent}
+
+ if ( isvalue(v1_MyRec) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(vt_MyRec) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_AllRec) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_AllRec.r1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_AllRec.r2) ) { setverdict(fail); } else { setverdict(pass); };
+
+ v1_MyRec := c1_MyRec;
+ v_AllRec := { r1 := c1_MyRec, r2 := c2_MyRec };
+
+ if ( isvalue(v1_MyRec) ) {setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(v_AllRec.r1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(c1_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(c_AllRec.r1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(p1_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(p_AllRec.r1) ) { setverdict(pass); } else { setverdict(fail); };
+
+ if ( isvalue(v1_MyRec .f1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(v_AllRec.r1.f1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(c1_MyRec .f1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(c_AllRec.r1.f1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(p1_MyRec .f1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(p_AllRec.r1.f1) ) { setverdict(pass); } else { setverdict(fail); };
+
+ if ( isvalue(v1_MyRec .f2) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_AllRec.r1.f2) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(c1_MyRec .f2) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(c_AllRec.r1.f2) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(p1_MyRec .f2) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(p_AllRec.r1.f2) ) { setverdict(fail); } else { setverdict(pass); };
+
+ v2_MyRec := c2_MyRec; //{ f1 := omit, f2 := "omit" };
+
+ if ( isvalue(v2_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(v_AllRec.r2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(c2_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(c_AllRec.r2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(p2_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(p_AllRec.r2) ) { setverdict(pass); } else { setverdict(fail); };
+
+ if ( isvalue(v2_MyRec .f1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_AllRec.r2.f1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(p2_MyRec .f1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(p_AllRec.r2.f1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(c2_MyRec .f1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(c_AllRec.r2.f1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v2_MyRec .f2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(v_AllRec.r2.f2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(p2_MyRec .f2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(p_AllRec.r2.f2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(c2_MyRec .f2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(c_AllRec.r2.f2) ) { setverdict(pass); } else { setverdict(fail); };
+
+ v1_MyRec := { f1 := omit, f2 := omit };
+
+ if ( isvalue(v1_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(v1_MyRec.f1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v1_MyRec.f2) ) { setverdict(fail); } else { setverdict(pass); };
+ // can't modify c1_MyRec or p1_MyRec
+
+/************** templates ***************/
+
+ vt_MyRec := { f1 := 5, f2 := omit };
+
+ if ( isvalue(vt_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(vt_MyRec.f1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(vt_MyRec.f2) ) { setverdict(fail); } else { setverdict(pass); };
+
+ vt_MyRec := { f1 := omit, f2 := "five" };
+
+ if ( isvalue(vt_MyRec) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(vt_MyRec.f1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(vt_MyRec.f2) ) { setverdict(pass); } else { setverdict(fail); };
+
+ vt_MyRec := { f1 := ?, f2 := "5" };
+
+ if ( isvalue(vt_MyRec) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(vt_MyRec.f1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(vt_MyRec.f2) ) { setverdict(pass); } else { setverdict(fail); };
+
+ vt_MyRec := { f1 := 5, f2 := * };
+
+ if ( isvalue(vt_MyRec) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(vt_MyRec.f1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(vt_MyRec.f2) ) { setverdict(fail); } else { setverdict(pass); };
+
+ vt_MyRec := { f1 := ?, f2 := * };
+
+ if ( isvalue(vt_MyRec) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(vt_MyRec.f1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(vt_MyRec.f2) ) { setverdict(fail); } else { setverdict(pass); };
+
+ if ( isvalue(pt_MyRec) ) { setverdict(pass); } else { setverdict(fail); }; // the fields are omit, but the record is bound
+ if ( isvalue(pt_MyRec.f1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(pt_MyRec.f2) ) { setverdict(fail); } else { setverdict(pass); };
+
+ //so here it is expanded instead
+ if ( isvalue(modifies vt_MyRec := { f1:=1, f2:="2" }) ) { setverdict(pass); } else {setverdict(fail, modifies vt_MyRec := { f1:=1, f2:="2" }, " should be bound"); };
+
+ if ( isvalue(t_MyRec) ) { setverdict(fail); } else { setverdict(pass); };
+
+ //testing ifpresent
+ if ( isvalue(ti) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(rrr1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(rrr2) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(rrr3) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+testcase recordIsvalue2() runs on recordOper_mycomp
+{
+ var recordOper_myrec8 x1_MyRec := { f1 := 5, f2 := omit };
+ var recordOper_myrec8 x2_MyRec := { f1 := omit, f2 := "omit" };
+ var template recordOper_myrec8 xt_MyRec := { f1 := omit, f2 := omit };
+ var AllRec x_AllRec := { r1 := x1_MyRec, r2 := x2_MyRec }
+ f_isvalue_record(x1_MyRec, x2_MyRec, x_AllRec, xt_MyRec) ;
+}
+
+ type record of integer IntegerList
+ type record Ctx{
+ IntegerList appData
+ }
+
+testcase CR_TR00016681() runs on recordOper_mycomp
+{
+ var Ctx vu;
+ // appData field: Unbound record of
+ // isvalue:false, isbound:false
+ if (isvalue(vu.appData)) { setverdict(fail); } else { setverdict(pass); }
+ if (isbound(vu.appData)) { setverdict(fail); } else { setverdict(pass); }
+ //lengthof(v1.appData) -> Dynamic Testcase Error
+
+ // The enclosing record: isbound === isvalue
+ if (isvalue(vu)) { setverdict (fail); } else { setverdict(pass); }
+ if (isbound(vu)) { setverdict (fail); } else { setverdict(pass); }
+
+ var Ctx v0 := {{}}
+ // appData field: 0-length record of
+ // isvalue: true, isbound:true
+ if (not isvalue(v0.appData)) { setverdict (fail); }
+ if (isbound(v0.appData)) { setverdict (pass); }
+ else { setverdict(fail); }
+
+ // The enclosing record: isbound === isvalue
+ if (isvalue(v0)) { setverdict (pass); } else { setverdict(fail); }
+ if (isbound(v0)) { setverdict (pass); } else { setverdict(fail); }
+
+ if (lengthof(v0.appData) == 0) { setverdict(pass); }
+ else { setverdict(fail); }
+
+ // appData field: 3-length with gaps
+ // isvalue: false, isbound:true
+ var Ctx v3 := { appData := { 1, -, 2 } }
+ if (isvalue(v3.appData)) { setverdict (fail); }
+ if (isbound(v3.appData)) { setverdict (pass); }
+ else { setverdict(fail); }
+
+ if (lengthof(v3.appData) == 3) { setverdict(pass); }
+ else { setverdict(fail); }
+
+ var integer i;
+ if (isbound(i)) { setverdict (fail); } else { setverdict(pass); }
+ if (isvalue(i)) { setverdict (fail); } else { setverdict(pass); }
+ i := 42;
+ if (isvalue(i)) { setverdict (pass); } else { setverdict(fail); }
+ if (isbound(i)) { setverdict (pass); } else { setverdict(fail); }
+}
+
+const MyRec2_2 c_myrec2_part:={
+ roc:={},
+ roi:={10,9,8},
+ u:={ r:={ /*i:=1,*/ x:=1.0, c:="one"}},
+ r:={ i:=1, x:=1.0, c:="one"}
+}
+
+const MyRec2_2 c_myrec2_1:={
+ roc:=omit,
+ roi:={},
+ u:={r:={ i:=1, x:=1.0, c:="one"}},
+ r:={ i:=1, x:=1.0, c:="one"}
+}
+
+type record MyRec2_2{
+ ROC roc optional,
+ ROI roi optional,
+ MyUnion1 u optional,
+ MyRecord1 r optional
+}
+
+type record of charstring ROC;
+type record of integer ROI;
+type record MyRecord1 {
+ integer i optional,
+ float x optional,
+ charstring c
+}
+
+type union MyUnion1 {
+ ROC roc,
+ integer i,
+ ROI roi,
+ MyRecord1 r
+}
+
+testcase tc_record_completlyInit() runs on recordOper_mycomp {
+ var MyRec2_2 vl_r1:=c_myrec2_1;
+ if(isbound(vl_r1)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r2:=c_myrec2_part;
+ if(isbound(vl_r2)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r3:=c_myrec2_part;
+ if(isbound(vl_r3)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r4:=c_myrec2_part;
+ if(isbound(vl_r4.roc)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r5:=c_myrec2_part;
+ if(isbound(vl_r5.roi)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r6:=c_myrec2_part;
+ if(isbound(vl_r6.u)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r7:=c_myrec2_part;
+ if(isbound(vl_r7.u.r)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r8:=c_myrec2_part;
+ if(isbound(vl_r8.u.r.i)){setverdict(fail)}else {setverdict(pass)};
+ var MyRec2_2 vl_r9:=c_myrec2_part;
+ if(isbound(vl_r9.u.r.x)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r10:=c_myrec2_part;
+ if(isbound(vl_r10.u.r.c)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r11:=c_myrec2_part;
+ if(isbound(vl_r11.u.i)){setverdict(fail)}else {setverdict(pass)};
+}
+
+testcase tc_record_partiallyInit12() runs on recordOper_mycomp {
+ var MyRec2_2 vl_r:={ r:={i:=5}}
+ if(isbound(vl_r.r)){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r.i)){setverdict(pass)}else {setverdict(fail)};
+}
+
+testcase tc_record_partiallyInit13() runs on recordOper_mycomp {
+ var MyRec2_2 vl_r:={ r:={i:=5,x:=-,c:= -}}
+ if(isbound(vl_r)){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r)){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vl_r.r.i)){setverdict(pass)}else {setverdict(fail)};
+}
+
+ testcase tc_record_unbound() runs on recordOper_mycomp {
+ var template MyRec2_2 vtl_rec2;
+ if(ispresent(vtl_rec2)) {setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_completlyInit_ispresent() runs on recordOper_mycomp {
+ var MyRec2_2 vl_r1:=c_myrec2_1;
+ if(ispresent(vl_r1)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r2:=c_myrec2_part;
+ if(ispresent(vl_r2)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r3:=c_myrec2_part;
+ if(ispresent(vl_r3.roc)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r4:=c_myrec2_part;
+ if(ispresent(vl_r4.roi)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r5:=c_myrec2_part;
+ if(ispresent(vl_r5.u)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r6:=c_myrec2_part;
+ if(ispresent(vl_r6.u.r)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r7:=c_myrec2_part;
+ if(ispresent(vl_r7.u.r.i)){setverdict(fail)}else {setverdict(pass)};
+ var MyRec2_2 vl_r8:=c_myrec2_part;
+ if(ispresent(vl_r8.u.r.x)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r9:=c_myrec2_part;
+ if(ispresent(vl_r9.u.r.c)){setverdict(pass)}else {setverdict(fail)};
+ var MyRec2_2 vl_r10:=c_myrec2_part;
+ if(ispresent(vl_r10.u.i)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_partiallyInit12_ispresent() runs on recordOper_mycomp {
+ var MyRec2_2 vl_r:={ r:={i:=5}}
+ if(ispresent(vl_r.r)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.r.i)){setverdict(pass)}else {setverdict(fail)};
+ }
+
+ testcase tc_record_partiallyInit13_ispresent() runs on recordOper_mycomp {
+ var MyRec2_2 vl_r:={ r:={i:=5,x:=-,c:= -}}
+ if(ispresent(vl_r)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.r)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.r.i)){setverdict(pass)}else {setverdict(fail)};
+ }
+
+ testcase tc_record_omit() runs on recordOper_mycomp {
+ var MyRec2_2 vl_r:={omit, omit, omit, omit}
+ if(ispresent(vl_r)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.roc)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.roi)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u.r)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u.r.i)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u.r.x)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u.r.c)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.r)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.r.i)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.r.x)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.r.c)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_omit2() runs on recordOper_mycomp {
+ var MyRec2_2 vl_r:={roc:=omit, roi:=omit,u:= omit,r:= omit}
+ if(ispresent(vl_r)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.roc)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.roi)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u.r)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u.r.i)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u.r.x)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.u.r.c)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.r)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.r.i)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.r.x)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.r.c)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_omit_HQ51693() runs on recordOper_mycomp {
+ var recordOper_myrec9 r1 := {omit, omit};
+ r1.f1 := r1.f2;
+ if(ispresent(r1.f1) or ispresent(r1.f2)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_recordOf_omit() runs on recordOper_mycomp {
+ var MyRec2_2 vl_r:=c_myrec2_1;
+ if(ispresent(vl_r.roc)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.roc[0])){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.roi)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vl_r.roi[0])){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vl_r.roi[90])){setverdict(fail)}else {setverdict(pass)};
+ }
+
+
+
+
+
+ //##########################################################################//
+
+ type record ExampleType {
+ integer a,
+ boolean b
+ }
+
+ template ExampleType exampleTemplate1 := {
+ a := 4,
+ b := false
+ }
+
+ testcase tc_rec_template() runs on recordOper_mycomp {
+
+ if (isbound(exampleTemplate1)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate1)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleTemplate1.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate1.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ }
+
+//###########################################################################//
+
+ template ExampleType exampleTemplate2(template boolean MyBoolTemplate := false, template integer MyintTemplate := 1) := {
+ a := MyintTemplate,
+ b := MyBoolTemplate
+ }
+
+ testcase tc_rec_template_param() runs on recordOper_mycomp {
+
+ if (isbound(exampleTemplate2)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate2)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleTemplate2.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate2.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleTemplate2(true))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate2(true))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleTemplate2(true).a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate2(true).a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleTemplate2(true, 3))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate2(true, 3))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleTemplate2(true, 3).a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate2(true, 3).a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ }
+
+//###########################################################################//
+
+ template ExampleType exampleTemplate3(template boolean MyBoolTemplate := false, template integer MyintTemplate := 1) modifies exampleTemplate2 := {
+ a := MyintTemplate,
+ b := MyBoolTemplate
+ }
+
+ testcase tc_rec_template_param_modifies() runs on recordOper_mycomp {
+
+ if (isbound(exampleTemplate3)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate3)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleTemplate3.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate3.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleTemplate3(true))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate3(true))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleTemplate3(true).a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate3(true).a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleTemplate3(true, 3))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate3(true, 3))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleTemplate3(true, 3).a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleTemplate3(true, 3).a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ }
+
+//###########################################################################//
+
+ type record ExampleType2 {
+ integer a,
+ ExampleType t
+ }
+
+
+ template ExampleType2 exampleEmbTemplate1 := {
+ a := 4,
+ t := {3, true}
+ }
+
+ testcase tc_emb_rec_template() runs on recordOper_mycomp {
+
+ if (isbound(exampleEmbTemplate1)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate1)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate1.t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate1.t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate1.t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate1.t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ }
+
+//###########################################################################//
+
+ template ExampleType2 exampleEmbTemplate2(template boolean MyBoolTemplate := false, template integer MyintTemplate := 1) := {
+ a := MyintTemplate,
+ t := {MyintTemplate, MyBoolTemplate}
+ }
+
+ testcase tc_emb_rec_template_param() runs on recordOper_mycomp {
+
+ if (isbound(exampleEmbTemplate2)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate2)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate2.t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate2.t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate2.t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate2.t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate2(true))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate2(true))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate2(true).t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate2(true).t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate2(true).t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate2(true).t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate2(true, 3))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate2(true, 3))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate2(true, 3).t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate2(true, 3).t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate2(true, 3).t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate2(true, 3).t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ }
+
+//###########################################################################//
+
+ template ExampleType2 exampleEmbTemplate3(template boolean MyBoolTemplate := false, template integer MyintTemplate := 1) modifies exampleEmbTemplate2 := {
+ a := MyintTemplate,
+ t := {MyintTemplate, MyBoolTemplate}
+ }
+
+ testcase tc_emb_rec_template_param_modifies() runs on recordOper_mycomp {
+
+ if (isbound(exampleEmbTemplate3)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate3)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate3.t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate3.t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate3.t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate3.t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate3(true))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate3(true))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate3(true).t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate3(true).t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate3(true).t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate3(true).t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate3(true, 3))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate3(true, 3))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate3(true, 3).t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate3(true, 3).t)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleEmbTemplate3(true, 3).t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleEmbTemplate3(true, 3).t.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ }
+
+//###########################################################################//
+
+template anytype exampleAnyTypeTemplate1 := {
+ ExampleType := {2, false}
+}
+
+testcase tc_anytype_rec_template() runs on recordOper_mycomp {
+
+ if (isbound(exampleAnyTypeTemplate1)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate1)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate1.ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate1.ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate1.ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate1.ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ }
+
+ template anytype exampleAnyTypeTemplate2(template boolean MyBoolTemplate := false, template integer MyintTemplate := 1) := {
+ ExampleType := {MyintTemplate, MyBoolTemplate}
+ }
+
+ testcase tc_anytype_rec_template_param() runs on recordOper_mycomp {
+
+ if (isbound(exampleAnyTypeTemplate2)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate2)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate2.ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate2.ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate2.ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate2.ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate2(true))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate2(true))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate2(true).ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate2(true).ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate2(true).ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate2(true).ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate2(true, 3))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate2(true, 3))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate2(true, 3).ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate2(true, 3).ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate2(true, 3).ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate2(true, 3).ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ }
+
+ template anytype exampleAnyTypeTemplate3(template boolean MyBoolTemplate := false, template integer MyintTemplate := 1) modifies exampleAnyTypeTemplate2 := {
+ ExampleType := {MyintTemplate, MyBoolTemplate}
+ }
+
+ testcase tc_anytype_rec_template_param_modifies() runs on recordOper_mycomp {
+
+ if (isbound(exampleAnyTypeTemplate3)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate3)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate3.ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate3.ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate3.ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate3.ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate3(true))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate3(true))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate3(true).ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate3(true).ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate3(true).ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate3(true).ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate3(true, 3))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate3(true, 3))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate3(true, 3).ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate3(true, 3).ExampleType)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(exampleAnyTypeTemplate3(true, 3).ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(exampleAnyTypeTemplate3(true, 3).ExampleType.a)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+ }
+
+
+//###########################################################################//
+
+control {
+ const recordOper_trecord cl_temp1:={ x1:=omit, x2:=3.4 }; // can constants be declared in the control part
+ const recordOper_trecof cl_temp2:={ 'AF12'O };
+ const recordOper_tset cl_temp3:={ x1:=234, x2:=1.9};
+ const recordOper_tsetof cl_temp4:={"f","8"};
+ const recordOper_tunion cl_temp5:={ x2:=1.3 };
+ const typedefrecordComp_myrec cl_const14 := { // complex record
+ x1 := { x1:=omit, x2:=3.4 },
+ x2 := { 'AF12'O },
+ x3 := { x1:=234, x2:=1.9},
+ x4 := {"f","8"},
+ x5 := { x2:=1.3 },
+ x6 := {1,2,3}
+ }
+ var recordOper_trecord vl_temp1; // can variables be declared in the control part
+ var recordOper_trecof vl_temp2;
+ var recordOper_tset vl_temp3;
+ var recordOper_tsetof vl_temp4;
+ var recordOper_tunion vl_temp5;
+ var typedefrecordComp_myrec vl_const14;
+
+ execute(recordAssign());
+ execute(recordAssignIncomplete());
+ execute(recordAssignOpt());
+ execute(recordAssignRec());
+ execute(recordAssignRecof());
+ execute(recordAssignSet());
+ execute(recordAssignSetof());
+ execute(recordAssignUnion());
+ execute(recordAssignElem());
+ execute(recordAssignElemOpt());
+ execute(recordAssignElemRec());
+ execute(recordAssignElemRecof());
+ execute(recordAssignElemSet());
+ execute(recordAssignElemSetof());
+ execute(recordAssignElemUnion());
+ execute(recordSizeof());
+ execute(recordConst());
+ execute(recordConstOpt());
+ execute(recordConstRec());
+ execute(recordConstRecof());
+ execute(recordConstSet());
+ execute(recordConstSetof());
+ execute(recordConstUnion());
+ execute(recordComp());
+ execute(recordCompOpt());
+ execute(recordCompOptField());
+ execute(recordCompRec());
+ execute(recordCompRecof());
+ execute(recordCompSet());
+ execute(recordCompSetof());
+ execute(recordCompUnion());
+ execute(recordSubtypes());
+ execute(recordIsvalue());
+ execute(recordIsbound());
+ execute(recordIsvalue2());
+
+ execute(CR_TR00016681());
+
+ execute(tc_record_completlyInit());
+ execute(tc_record_partiallyInit12());
+ execute(tc_record_partiallyInit13());
+ execute(tc_record_unbound());
+ execute(tc_record_completlyInit_ispresent());
+ execute(tc_record_partiallyInit12_ispresent());
+ execute(tc_record_partiallyInit13_ispresent());
+ execute(tc_record_omit());
+ execute(tc_record_omit2());
+ execute(tc_record_omit_HQ51693());
+ execute(tc_recordOf_omit());
+
+ execute(tc_rec_template());
+ execute(tc_rec_template_param());
+ execute(tc_rec_template_param_modifies());
+
+ execute(tc_emb_rec_template());
+ execute(tc_emb_rec_template_param());
+ execute(tc_emb_rec_template_param_modifies());
+
+ execute(tc_anytype_rec_template());
+ execute(tc_anytype_rec_template_param());
+ execute(tc_anytype_rec_template_param_modifies());
+}
+}
+with {
+ extension "anytype ExampleType"
+}
\ No newline at end of file
diff --git a/Regression_Test_java/src/TsetOper.ttcn b/Regression_Test_java/src/TsetOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..90201d605efd2503941d430e36d1e92ad5c81534
--- /dev/null
+++ b/Regression_Test_java/src/TsetOper.ttcn
@@ -0,0 +1,1193 @@
+/******************************************************************************
+ * 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
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TsetOper {
+// ********** Type definitions *********************
+type component setOper_mycomp {};
+type set typedefset_empty {};
+type enumerated setOper_myenum {xx1,xx2,xx3};
+type record setOper_trecord {
+ integer x1 optional,
+ float x2 };
+type record of octetstring setOper_trecof;
+type set setOper_tset {
+ integer x1,
+ float x2 optional };
+type set of charstring setOper_tsetof;
+type union setOper_tunion {
+ integer x1,
+ float x2 };
+type set setOper_myset1 { // set from basic types
+ integer x1,
+ float x2,
+ setOper_myenum x3 };
+type set setOper_myset2 { // set from basic types, with optional field
+ integer x1,
+ float x2,
+ setOper_myenum x3,
+ integer x4 optional };
+type set setOper_myset3 { // set from record, with optional field
+ setOper_trecord x1,
+ setOper_trecord x2 optional
+ };
+type set setOper_myset4 { // set from record of, with optional field
+ setOper_trecof x1,
+ setOper_trecof x2 optional
+ };
+type set setOper_myset5 { // set from set, with optional field
+ setOper_tset x1,
+ setOper_tset x2 optional
+ };
+type set setOper_myset6 { // set from set of, with optional field
+ setOper_tsetof x1,
+ setOper_tsetof x2 optional
+ };
+type set setOper_myset7 { // set from union, with optional field
+ setOper_tunion x1,
+ setOper_tunion x2 optional
+ };
+type set typedefsetComp_myset {
+ setOper_trecord x1,
+ setOper_trecof x2,
+ setOper_tset x3,
+ setOper_tsetof x4 optional,
+ setOper_tunion x5,
+ integer x6[3]
+ };
+// *************** Constanst ***********************
+const setOper_trecord setOper_temp1:={ x1:=omit, x2:=3.4 };
+const setOper_trecof setOper_temp2:={ 'AF12'O };
+const setOper_tset setOper_temp3:={ x1:=234, x2:=1.9};
+const setOper_tsetof setOper_temp4:={"f","8"};
+const setOper_tunion setOper_temp5:={ x2:=1.3 };
+const setOper_myset1 setOper_const1:={ //set with basic types
+x1:=1,
+x2:=1.2,
+x3:=xx2 };
+const setOper_myset2 setOper_const2:={ //set with basic types, with optional field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=2 };
+const setOper_myset2 setOper_const3:={ //set with basic types, with omited field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=omit };
+const setOper_myset3 setOper_const4:={ //set from record
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=setOper_temp1
+};
+const setOper_myset3 setOper_const5:={ //set from record, with omited field
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=omit
+};
+const setOper_myset4 setOper_const6:={ //set from record of
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=setOper_temp2
+};
+const setOper_myset4 setOper_const7:={ //set from record of, with omited field
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=omit
+};
+const setOper_myset5 setOper_const8:={ //set from set
+ x1:={ x1:=2, x2:=1.3},
+ x2:=setOper_temp3
+};
+const setOper_myset5 setOper_const9:={ //set from set, with omited field
+ x1:={ x1:=2, x2:=1.3},
+ x2:=omit
+};
+const setOper_myset6 setOper_const10:={ //set from set of
+ x1:={"a","b"},
+ x2:=setOper_temp4 //{"f","8"},
+};
+const setOper_myset6 setOper_const11:={ //set from set of, with omited field
+ x1:={"a","b"},
+ x2:=omit
+};
+const setOper_myset7 setOper_const12:={ //set from union
+ x1:={ x1 :=3 },
+ x2:=setOper_temp5 //{ x2:=1.3 }
+};
+const setOper_myset7 setOper_const13:={ //set from union, with omited field
+ x1:={ x1 :=3 },
+ x2:=omit
+};
+const typedefsetComp_myset setOper_const14 := { // complex set
+ x1 := { x1:=omit, x2:=3.4 },
+ x2 := { 'AF12'O },
+ x3 := { x1:=234, x2:=1.9},
+ x4 := {"f","8"},
+ x5 := { x2:=1.3 },
+ x6 := {1,2,3}
+}
+
+testcase setAssign() runs on setOper_mycomp{
+var setOper_myset1 x1:={ //set with basic types
+x1:=1,
+x2:=1.2,
+x3:=xx2 };
+var setOper_myset1 x2,x3;
+x2:={ x1:=1, x2:=1.2, x3:=xx2 };
+x3:={ x2:=1.2, x1:=1, x3:=xx2 };
+if (x1.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x1==1) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+if (x3.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setAssignOpt() runs on setOper_mycomp{
+var integer inttemp:=2;
+var setOper_myset2 x1:={ //set with basic types, with optional field
+ x1:=1,
+ x2:=1.2,
+ x3:=xx2,
+ x4:=inttemp}; //2
+var setOper_myset2 x2:={ //set with basic types, with omited field
+ x1:=1,
+ x2:=1.2,
+ x3:=xx2,
+ x4:=omit };
+var setOper_myset2 x3, x4;
+x3:={ //set with basic types, with optional field
+ x1:=1,
+ x2:=1.2,
+ x3:=xx2,
+ x4:=inttemp }; //2
+x4:={ //set with basic types, with omited field
+ x1:=1,
+ x2:=1.2,
+ x3:=xx2,
+ x4:=omit };
+//at declaration, with optional field
+if (x1.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x4==2) {setverdict(pass);}
+ else {setverdict(fail);}
+//at declaration, with omited field
+if (x2.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2.x4))) {setverdict(pass);}
+ else {setverdict(fail);}
+//later, with optional field
+if (x3.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x4==2) {setverdict(pass);}
+ else {setverdict(fail);}
+//later, with optional field
+if (x4.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x4))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setAssignRec() runs on setOper_mycomp{
+var setOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var setOper_myset3 x1:={ //set from record
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+var setOper_myset3 x2:={ //set from record, with omited field
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=omit
+};
+var setOper_myset3 x3,x4;
+x3:={ //set from record
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x4:={ //set from record, with omited field
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=omit
+};
+if (x1.x1.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x1==1) {setverdict(pass);} //at declaration, omit
+ else {setverdict(fail);}
+if (x2.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x1.x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x3.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x1.x1==1) {setverdict(pass);} //later, omit
+ else {setverdict(fail);}
+if (x4.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setAssignRecof() runs on setOper_mycomp{
+var setOper_trecof temp2:={'AF12'O};
+var setOper_myset4 x1:={ //set from record of
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=temp2
+};
+var setOper_myset4 x2:={ //set from record of, with omited field
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=omit
+};
+var setOper_myset4 x3,x4
+x3:={ //set from record of
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=temp2
+};
+x4:={ //set from record of, with omited field
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=omit
+};
+if (x1.x1[0]=='12AB'O) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1[0]=='12AB'O) {setverdict(pass);} //at declaration, omit
+ else {setverdict(fail);}
+if (x2.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x1[0]=='12AB'O) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x3.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x1[0]=='12AB'O) {setverdict(pass);} //later, omit
+ else {setverdict(fail);}
+if (x4.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setAssignSet() runs on setOper_mycomp{
+var setOper_tset temp1:={ x1:=2, x2:=omit };
+var setOper_myset5 x1:={ //set from set
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+var setOper_myset5 x2:={ //set from set, with omited field
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=omit
+};
+var setOper_myset5 x3,x4;
+x3:={ //set from set
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x4:={ //set from set, with omited field
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=omit
+};
+if (x1.x1.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x1==1) {setverdict(pass);} //at declaration, omit
+ else {setverdict(fail);}
+if (x2.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x1.x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x3.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x1.x1==1) {setverdict(pass);} //later, omit
+ else {setverdict(fail);}
+if (x4.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setAssignSetof() runs on setOper_mycomp{
+var setOper_tsetof temp2:={"a","7"};
+var setOper_myset6 x1:={ //set from set of
+ x1:={ "1", "a" },
+ x2:=temp2
+};
+var setOper_myset6 x2:={ //set from set of, with omited field
+ x1:={ "1", "a" },
+ x2:=omit
+};
+var setOper_myset6 x3,x4
+x3:={ //set from set of
+ x1:={ "1", "a" },
+ x2:=temp2
+};
+x4:={ //set from set of, with omited field
+ x1:={ "1","a" },
+ x2:=omit
+};
+if (x1.x1[0]=="1") {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1[0]=="1") {setverdict(pass);} //at declaration, omit
+ else {setverdict(fail);}
+if (x2.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x1[0]=="1") {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x3.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x1[0]=="1") {setverdict(pass);} //later, omit
+ else {setverdict(fail);}
+if (x4.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setAssignUnion() runs on setOper_mycomp{
+var setOper_tunion temp5 := {x2:=1.3}
+var setOper_myset7 x1:={ //set from union
+ x1:={ x1 :=3 },
+ x2:=temp5 //{ x2:=1.3 }
+};
+var setOper_myset7 x2:={ //set from union, with omited field
+ x1:={ x1 :=3 },
+ x2:=omit
+};
+var setOper_myset7 x3,x4;
+x3:={ //set from union
+ x1:={ x1 :=3 },
+ x2:=temp5 //{ x2:=1.3 }
+};
+x4:={ //set from union, with omited field
+ x1:={ x1 :=3 },
+ x2:=omit
+};
+if (x1.x1.x1==3) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (ischosen(x1.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x1==3) {setverdict(pass);} //at declaration, omit
+ else {setverdict(fail);}
+if (ischosen(x2.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x1.x1==3) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (ischosen(x3.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x3.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x1.x1==3) {setverdict(pass);} //later, omit
+ else {setverdict(fail);}
+if (ischosen(x4.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x4.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setAssignElem() runs on setOper_mycomp{
+var setOper_myset1 x1:={ //set with basic types
+x1:=1,
+x2:=1.2,
+x3:=xx2 };
+x1.x2:=3.4;
+if (x1.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase setAssignElemOpt() runs on setOper_mycomp{
+var integer inttemp:=2;
+var setOper_myset2 x1:={ //set with basic types
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=omit } ; //2
+var setOper_myset2 x2, x3, x4;
+x2:=x1;
+x3:={x1:=1, x2:=1.2, x3:=xx2, x4:=inttemp };
+x4:=x3;
+x1.x1:=2; //not optional field
+x2.x4:=3; //optional field; omited-> value
+x3.x4:=3; //optional field; value-> value
+x4.x4:=omit; //optional field; value -> omited
+//not optional field
+if (x1.x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x1.x4))) {setverdict(pass);}
+ else {setverdict(fail);}
+//optional field, omited -> value
+if (x2.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x4==3) {setverdict(pass);}
+ else {setverdict(fail);}
+//optional field; value-> value
+if (x3.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3.x4==3) {setverdict(pass);}
+ else {setverdict(fail);}
+//optional field; value -> omited
+if (x4.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(x4.x4))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setAssignElemRec() runs on setOper_mycomp{
+var setOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var setOper_myset3 x1;
+x1:={ //set from record
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x1.x1.x1:=2;
+temp1.x1:=3;
+x1.x2:=temp1;
+if (x1.x1.x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase setAssignElemRecof() runs on setOper_mycomp{
+var setOper_trecof temp2:={'AF12'O};
+var setOper_myset4 x1:={ //set from record of
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=temp2
+};
+x1.x1[1]:='34AB'O;
+if (x1.x1[0]=='12AB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x1[1]=='34AB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setAssignElemSet() runs on setOper_mycomp{
+var setOper_tset temp1:={ x1:=2, x2:=omit };
+var setOper_myset5 x1:={ //set from set
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x1.x1.x2:=3.4;
+if (x1.x1.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x1.x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setAssignElemSetof() runs on setOper_mycomp{
+var setOper_tsetof temp2:={"a","7"};
+var setOper_myset6 x1:={ //set from set of
+ x1:={ "1", "a" },
+ x2:=temp2
+};
+x1.x1[0]:="h";
+if (x1.x1[0]=="h") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setAssignElemUnion() runs on setOper_mycomp{
+var setOper_tunion temp5 := {x2:=1.3}
+var setOper_myset7 x1:={ //set from union
+ x1:={ x1 :=3 },
+ x2:=temp5 //{ x2:=1.3 }
+};
+x1.x1.x2:=3.4;
+if (x1.x1.x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x1.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1.x2==temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setSizeof() runs on setOper_mycomp{
+var integer inttemp:=2;
+var setOper_myset2 x1:={ //set with basic types, with optional field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=inttemp}; //2
+var setOper_myset2 x2:={ //set with basic types, with omited field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=omit };
+var setOper_myset2 x3, x4;
+x3:={ //set with basic types, with optional field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=inttemp }; //2
+x4:={ //set with basic types, with omited field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=omit };
+//if (sizeof(x1)==4) {setverdict(pass);} //at declaration, with optional field
+// else {setverdict(fail);}
+//if (sizeof(x2)==3) {setverdict(pass);} //at declaration, with omited field
+// else {setverdict(fail);}
+//if (sizeof(x3)==4) {setverdict(pass);} //later, with optional field
+// else {setverdict(fail);}
+//if (sizeof(x4)==3) {setverdict(pass);} //testcase, with optional field
+// else {setverdict(fail);}
+//if (sizeof(setOper_myset2)==4) {setverdict(pass);} // size of type
+// else {setverdict(fail);}
+}
+
+testcase setConst() runs on setOper_mycomp{
+const setOper_myset1 const1:={ //set with basic types
+x1:=1,
+x2:=1.2,
+x3:=xx2 };
+if (setOper_const1.x1==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (setOper_const1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const1.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1.x1==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setConstOpt() runs on setOper_mycomp{
+const setOper_myset2 const2:={ //set with basic types, with optional field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=2 };
+const setOper_myset2 const3:={ //set with basic types, with omited field
+x1:=1,
+x2:=1.2,
+x3:=xx2,
+x4:=omit };
+//definition part, with optional field
+if (setOper_const2.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const2.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const2.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const2.x4==2) {setverdict(pass);}
+ else {setverdict(fail);}
+//definition part, with omited field
+if (setOper_const3.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const3.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const3.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(setOper_const3.x4))) {setverdict(pass);}
+ else {setverdict(fail);}
+//testcase, with optional field
+if (const2.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const2.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const2.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const2.x4==2) {setverdict(pass);}
+ else {setverdict(fail);}
+//testcase, with optional field
+if (const3.x1==1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const3.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const3.x3==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(const3.x4))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setConstRec() runs on setOper_mycomp{
+const setOper_myset3 const4:={ //set from record
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=setOper_temp1
+};
+const setOper_myset3 const5:={ //set from record, with omited field
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=omit
+};
+if (setOper_const4.x1.x1==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (setOper_const4.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const4.x2==setOper_temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const5.x1.x1==1) {setverdict(pass);} //definition part, omit
+ else {setverdict(fail);}
+if (setOper_const5.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(setOper_const5.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const4.x1.x1==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const4.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const4.x2==setOper_temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const5.x1.x1==1) {setverdict(pass);} //testcase part, omit
+ else {setverdict(fail);}
+if (const5.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(const5.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setConstRecof() runs on setOper_mycomp{
+const setOper_myset4 const6:={ //set from record of
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=setOper_temp2
+};
+const setOper_myset4 const7:={ //set from record of, with omited field
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=omit
+};
+if (setOper_const6.x1[0]=='12AB'O) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (setOper_const6.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const6.x2==setOper_temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const7.x1[0]=='12AB'O) {setverdict(pass);} //definition part, omit
+ else {setverdict(fail);}
+if (setOper_const7.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(setOper_const7.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const6.x1[0]=='12AB'O) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const6.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const6.x2==setOper_temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const7.x1[0]=='12AB'O) {setverdict(pass);} //testcase part, omit
+ else {setverdict(fail);}
+if (const7.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(const7.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setConstSet() runs on setOper_mycomp{
+const setOper_myset5 const8:={ //set from set
+ x1:={ x1:=2, x2:=1.3},
+ x2:=setOper_temp3
+};
+const setOper_myset5 const9:={ //set from set, with omited field
+ x1:={ x1:=2, x2:=omit},
+ x2:=omit
+};
+if (setOper_const8.x1.x1==2) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (setOper_const8.x1.x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const8.x2==setOper_temp3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const9.x1.x1==2) {setverdict(pass);} //definition part, omit
+ else {setverdict(fail);}
+if (setOper_const9.x1.x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(setOper_const9.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const8.x1.x1==2) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const8.x1.x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const8.x2==setOper_temp3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const9.x1.x1==2) {setverdict(pass);} //testcase part, omit
+ else {setverdict(fail);}
+if (not(ispresent(const9.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(const9.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setConstSetof() runs on setOper_mycomp{
+const setOper_myset6 const10:={ //set from set of
+ x1:={"a","b"},
+ x2:=setOper_temp4 //{"f","8"},
+};
+const setOper_myset6 const11:={ //set from set of, with omited field
+ x1:={"a","b"},
+ x2:=omit
+};
+if (setOper_const10.x1[0]=="a") {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (setOper_const10.x1[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const10.x2==setOper_temp4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const11.x1[0]=="a") {setverdict(pass);} //definition part, omit
+ else {setverdict(fail);}
+if (setOper_const11.x1[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(setOper_const11.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const10.x1[0]=="a") {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const10.x1[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (const10.x2==setOper_temp4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const11.x1[0]=="a") {setverdict(pass);} //testcase part, omit
+ else {setverdict(fail);}
+if (const11.x1[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ispresent(const11.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setConstUnion() runs on setOper_mycomp{
+const setOper_myset7 const12:={ //set from union
+ x1:={ x1 :=3 },
+ x2:=setOper_temp5 //{ x2:=1.3 }
+};
+const setOper_myset7 const13:={ //set from union, with omited field
+ x1:={ x1 :=3 },
+ x2:=omit
+};
+if (setOper_const12.x1.x1==3) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (setOper_const12.x2==setOper_temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+if (setOper_const13.x1.x1==3) {setverdict(pass);} //definition part, omit
+ else {setverdict(fail);}
+if (not(ispresent(setOper_const13.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const12.x1.x1==3) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const12.x2==setOper_temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const13.x1.x1==3) {setverdict(pass);} //testcase part, omit
+ else {setverdict(fail);}
+if (not(ispresent(const13.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase setComp() runs on setOper_mycomp{
+var setOper_myset1 x1,x2,x3,x4;
+x1:={ x1:=1, x2:=1.2, x3:=xx2 };
+x2:={ x1:=1, x2:=1.2, x3:=xx2 };
+x3:={ x1:=1, x2:=1.24, x3:=xx2 };
+x4:={ x2:=1.2, x1:=1, x3:=xx2 };
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4==x2) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+if (not(x4==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x4!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase setCompOpt() runs on setOper_mycomp{
+var integer inttemp:=2; // set with basic types with optional field
+var setOper_myset2 x1,x2,x3;
+x1 :={ x1:=1, x2:=1.2, x3:=xx2, x4:=inttemp }; //inntemp=2
+x2:= { x1:=1, x2:=1.2, x3:=xx2, x4:=omit };
+x3:= { x1:=1, x2:=1.2, x3:=xx2, x4:=omit };
+if (x2==x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x2!=x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setCompRec() runs on setOper_mycomp{
+var setOper_trecord temp1:={ x1:=omit, x2:=3.4 }; // set with record
+var setOper_myset3 x1,x2,x3;
+x1 :={
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x2 :={
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x3 :={
+ x1:={ x1:=2, x2:=1.2 },
+ x2:=temp1
+};
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase setCompRecof() runs on setOper_mycomp{
+var setOper_trecof temp2:={'AF12'O};
+var setOper_myset4 x1,x2,x3;
+x1:={ //set from record of
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=temp2
+};
+x2:={
+ x1:={ '12AB'O, 'CD12'O },
+ x2:=temp2
+};
+x3:={
+ x1:={ '12AB'O },
+ x2:=temp2
+};
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setCompSet() runs on setOper_mycomp{
+var setOper_tset temp1:={ x1:=2, x2:=omit };
+var setOper_myset5 x1,x2,x3
+x1:={ //set from set
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x2:={
+ x1:={ x1:=1, x2:=1.2 },
+ x2:=temp1
+};
+x3:={
+ x1:={ x1:=4, x2:=1.2 },
+ x2:=temp1
+};
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x2==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setCompSetof() runs on setOper_mycomp{
+var setOper_tsetof temp2:={"a","7"};
+var setOper_myset6 x1,x2,x3;
+x1:={ //set from set of
+ x1:={ "1", "a" },
+ x2:=temp2
+};
+x2:={
+ x1:={ "1", "a" },
+ x2:=temp2
+};
+x3:={
+ x1:={ "1", "a", "k" },
+ x2:=temp2
+};
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x2==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setCompUnion() runs on setOper_mycomp{
+var setOper_tunion temp5 := {x2:=1.3}
+var setOper_myset7 x1,x2,x3;
+x1:={ //set from union
+ x1:={ x1 :=3 },
+ x2:=temp5 //{ x2:=1.3 }
+};
+x2:={
+ x1:={ x1 :=3 },
+ x2:=temp5 //{ x2:=1.3 }
+};
+x3:={
+ x1:={ x2 :=3.9 },
+ x2:=temp5 //{ x2:=1.3 }
+};
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+type set myset1 {
+ integer f1 (0..255),
+ charstring f2 length(0..255)
+}
+type myset1 myset2 ({f1 := 0, f2 := ""})
+type myset1 myset3
+type myset1 myset4 ({f1 := c_mysetlen1, f2 := "hello"}, {f1 := c_mysetlen2, f2 := "world"})
+
+const integer c_mysetlen1 := 255
+const integer c_mysetlen2 := c_mysetlen1
+const myset4 c_myset1 := {f1 := 255, f2 := "world"}
+
+template myset4 t_myset1 := {f1 := 255, f2 := "hello"}
+// The following line shouldn't work. Delete it later.
+template myset4 t_myset2 modifies t_myset1 := {f1 := 1, f2 := ""}
+
+function f_set1() return myset2 { return {f1 := 0, f2 := ""} }
+
+function f_set2() return boolean {
+ var integer v_i1 := 100
+ var charstring v_s1 := "abc"
+ var myset4 v_myset1 := valueof(t_myset1)
+ // It doesn't work yet: `var myset4 v_myset2 := {f1 := v_i1, f2 := v_s1}'. Replace
+ // the test later.
+ var myset4 v_myset2 := valueof(modifies t_myset1 := {f2 := ""})
+ var myset4 v_myarr1[3] := {c_myset1, {f1 := 255, f2 := "he" & "llo"}, valueof(t_myset1)}
+ if (v_myset1 != v_myarr1[2]) { return false }
+ else {
+ log(v_myset1)
+ log(v_myarr1)
+ if (v_myset1.f1 == v_myarr1[0].f1 and v_myset2.f1 == v_myarr1[1].f1 and 255 == v_myarr1[2].f1 and
+ v_myset1.f2 != v_myarr1[0].f2 and v_myset2.f2 != v_myarr1[1].f2 and "hello" == v_myarr1[2].f2) {
+ return true
+ }
+ return false
+ }
+}
+
+testcase setSubtypes() runs on setOper_mycomp {
+ var template myset1 vt_myset1 := { f1 := 0, f2 := "" }
+ var myset1 v_myset1 := { f1 := valueof(vt_myset1.f1), f2 := valueof(vt_myset1.f2) }
+
+ if (f_set1() == v_myset1 and valueof(vt_myset1) == f_set1()) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (f_set2()) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+testcase setIsvalue() runs on setOper_mycomp{
+ var typedefset_empty v1;
+ var setOper_trecord vs2_def;
+ var setOper_trecord v2;
+ v2.x1 := 42;
+
+ if ( isvalue(v1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(vs2_def) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v2) ) { setverdict(fail); } else { setverdict(pass); };
+
+ var setOper_trecord vs2_part := { -, 1.0 };
+ if ( isvalue(vs2_part) ) { setverdict(fail); } else { setverdict(pass); };
+ vs2_part.x1 := omit;
+ if ( isvalue(vs2_part) ) { setverdict(pass); } else { setverdict(fail); };
+
+ var setOper_trecord vs2_om := { omit, - };
+ if ( isvalue(vs2_om) ) { setverdict(fail); } else { setverdict(pass); };
+ vs2_om.x2 := 33.0;
+ if ( isvalue(vs2_om) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+testcase setIsbound() runs on setOper_mycomp{
+ var typedefset_empty v1;
+ var setOper_trecord vs2_def;
+ var setOper_trecord v2;
+ v2.x1 := 42;
+
+ if ( isbound(v1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(vs2_def) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(vs2_def.x1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(vs2_def.x2) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(v2) ) { setverdict(pass); } else { setverdict(fail); };
+
+ var setOper_trecord vs2_part := { -, 1.0 };
+ if ( isbound(vs2_part) ) { setverdict(pass); } else { setverdict(fail); };
+ vs2_part.x1 := omit;
+ if ( isbound(vs2_part) ) { setverdict(pass); } else { setverdict(fail); };
+
+ var setOper_trecord vs2_om := { omit, - };
+ if ( isbound(vs2_om) ) { setverdict(pass); } else { setverdict(fail); };
+ vs2_om.x2 := 33.0;
+ if ( isbound(vs2_om) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+control {
+ const setOper_trecord cl_temp1:={ x1:=omit, x2:=3.4 }; //constant in control part
+ const setOper_trecof cl_temp2:={ 'AF12'O };
+ const setOper_tset cl_temp3:={ x1:=234, x2:=1.9};
+ const setOper_tsetof cl_temp4:={"f","8"};
+ const setOper_tunion cl_temp5:={ x2:=1.3 };
+ const typedefsetComp_myset cl_const14 := {
+ x1 := { x1:=omit, x2:=3.4 },
+ x2 := { 'AF12'O },
+ x3 := { x1:=234, x2:=1.9},
+ x4 := {"f","8"},
+ x5 := { x2:=1.3 },
+ x6 := {1,2,3}
+ }
+ var setOper_trecord vl_temp1; //variable in control part
+ var setOper_trecof vl_temp2;
+ var setOper_tset vl_temp3;
+ var setOper_tsetof vl_temp4;
+ var setOper_tunion vl_temp5;
+ var typedefsetComp_myset vl_const14;
+
+ execute(setAssign());
+ execute(setAssignOpt());
+ execute(setAssignRec());
+ execute(setAssignRecof());
+ execute(setAssignSet());
+ execute(setAssignSetof());
+ execute(setAssignUnion());
+ execute(setAssignElem());
+ execute(setAssignElemOpt());
+ execute(setAssignElemRec());
+ execute(setAssignElemRecof());
+ execute(setAssignElemSet());
+ execute(setAssignElemSetof());
+ execute(setAssignElemUnion());
+// execute(setSizeof());
+ execute(setConst());
+ execute(setConstOpt());
+ execute(setConstRec());
+ execute(setConstRecof());
+ execute(setConstSet());
+ execute(setConstSetof());
+ execute(setConstUnion());
+ execute(setComp());
+ execute(setCompOpt());
+ execute(setCompRec());
+ execute(setCompRecof());
+ execute(setCompSet());
+ execute(setCompSetof());
+ execute(setCompUnion());
+ execute(setSubtypes());
+ execute(setIsvalue());
+ execute(setIsbound());
+}
+}
diff --git a/Regression_Test_java/src/TsetofMatch.ttcn b/Regression_Test_java/src/TsetofMatch.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..dc71d68670ced14806a8875ab4b385edaaa247b3
--- /dev/null
+++ b/Regression_Test_java/src/TsetofMatch.ttcn
@@ -0,0 +1,625 @@
+/******************************************************************************
+ * 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
+ * Forstner, Matyas
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TsetofMatch {
+// Type definitions
+
+type component my_comp {};
+type enumerated my_enum {amstel, buckler, coronita, desperados};
+type record of integer recordof_int;
+//type union my_union {
+// int x1,
+// recordof_int x2
+//};
+
+type set of integer setof_int; // set of basic type
+type set of my_enum setof_enum; // set of enum
+//type set of my_union setof_union; // set of union
+type set of recordof_int setof_recordof; // set of record of
+type set of setof_int setof_setof; // recursive set of
+
+// Constants
+
+const recordof_int record_element1:={4,3,2};
+
+const setof_int setof_const1:={1,2,3,4,5};
+const setof_enum setof_const2:={amstel, coronita};
+//const setof_union setof_const3:={{1,{1,2,3}}, {9,{4}}};
+const setof_recordof setof_const4:={record_element1, {5,4,3}, {2}};
+const setof_setof setof_const5:={{0,1}, setof_const1, {1}};
+
+// Templates
+
+template setof_int setof_temp1 := {1,2,3,4};
+template setof_enum setof_temp2 := {amstel, buckler, ?};
+template setof_enum setof_temp3 := {?, buckler, ?, buckler};
+template setof_int setof_temp4 := {*};
+template setof_int setof_temp5 := {1, *, 3};
+template setof_recordof setof_temp6 := {*, {1,2}, {3}, *};
+template setof_setof setof_temp7 := {{?,1}, {7,3}, ?, {5,*}};
+template setof_setof setof_temp8 := {{1,*}, * length (4)};
+template setof_int setof_temp9 := ({1},{2,?},{(3,4,5),?,?});
+template setof_setof setof_temp10 := {* length(2), * length(3), *};
+
+// Testcases - non-template part
+
+testcase setofIntAssign() runs on my_comp {
+var setof_int x1:= {25, 13, 37};
+var setof_int x2, x3, x4;
+x2:={32,12};
+x3:={11};
+x3:={11,22};
+x4:={};
+
+if (x1[0]==25) {setverdict(pass);} // at declaration
+ else {setverdict(fail);}
+if (x1[1]==13) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2[0]==32) {setverdict(pass);} // later
+ else {setverdict(fail);}
+if (x2[1]==12) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3[0]==11) {setverdict(pass);} // after changing size
+ else {setverdict(fail);}
+if (x3[1]==22) {setverdict(pass);}
+ else {setverdict(fail);}
+if (sizeof(x4)==0) {setverdict(pass);} // empty set of
+ else {setverdict(fail);}
+}
+
+testcase setofIntEq() runs on my_comp {
+// setof_int setof_const1:={1,2,3,4,5};
+var setof_int x1, x2, x3, x4, x5, x6, x7, x8, x9, x10;
+x1 := {1, 2, 3, 4, 5};
+x2 := {1, 3, 2, 5, 4};
+x3 := {4, 3, 2, 1, 5};
+x4 := {5, 1, 4, 3, 2};
+x5 := {3, 4, 5, 2, 1};
+x6 := {1, 2, 3, 4, 4};
+x7 := {1, 1, 1, 1, 1};
+x8 := {1, 2, 3, 4, 5, 6};
+x9:= {1, 4, 3, 2};
+//equality - the same order
+if (x1==setof_const1) {setverdict(pass);}
+ else {setverdict(fail);}
+//equality - other order
+if (x2==setof_const1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x3==setof_const1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4==setof_const1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x5==setof_const1) {setverdict(pass);}
+ else {setverdict(fail);}
+//non-equality - unmatched elements
+if (x6!=setof_const1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x7!=setof_const1) {setverdict(pass);}
+ else {setverdict(fail);}
+//non-equality - too many elements
+if (x8!=setof_const1) {setverdict(pass);}
+ else {setverdict(fail);}
+//non-equality - too few elements
+if (x9!=setof_const1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofSetofEq() runs on my_comp {
+var setof_setof x1, x2, x3, x4, x5, x6, x7;
+x1 := {{1,2},{3,4}};
+x2 := {{1,2},{3,4}};
+x3 := {{3,4},{1,2}};
+x4 := {{2,1},{4,3}};
+x5 := {{2,1},{4,3},{1,2}};
+x6 := {{4,1},{3,2}};
+x7 := {{1},{2,4}};
+//equality - in same order
+if (x2==x1) {setverdict(pass);}
+ else {setverdict(fail);}
+//equality - different orders
+if (x3==x1) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x4==x1) {setverdict(pass);}
+ else {setverdict(fail);}
+//non-equality - too many elements
+if (x5!=x1) {setverdict(pass);}
+ else {setverdict(fail);}
+//non-equality - elements not matching
+if (x6!=x1) {setverdict(pass);}
+ else {setverdict(fail);}
+//non-equality - elements size not proper
+if (x7!=x1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+// Testcases - template part
+
+testcase tsetofIntSpecValueMatch() runs on my_comp {
+//template setof_int setof_temp1 := {1,2,3,4};
+var setof_int x1, x2, x3, x4, x5, x6, x7, x8, x9, x10;
+x1 := {1, 2, 3, 4}
+x2 := {1, 3, 2, 4}
+x3 := {4, 3, 2, 1}
+x4 := {2, 1, 4, 3}
+x5 := {3, 4, 1, 2}
+x6 := {1, 2, 3}
+x7 := {1, 2, 3, 4, 5}
+x8 := {4, 3, 2, 2}
+x9 := {1, 1, 4, 3}
+x10 := {3, 5, 1, 2}
+//match - in same order
+if (match(x1,setof_temp1)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match - in different orders
+if (match(x2,setof_temp1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x3,setof_temp1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x4,setof_temp1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x5,setof_temp1)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: too few elements
+if (not(match(x6,setof_temp1))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: too many elements
+if (not(match(x7,setof_temp1))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: two different elements only match one
+if (not(match(x8,setof_temp1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(match(x9,setof_temp1))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: unmatched element
+if (not(match(x10,setof_temp1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase tsetofEnumAnyValueMatch() runs on my_comp {
+//template setof_enum setof_temp2 := {amstel, buckler, ?};
+//template setof_enum setof_temp3 := {?, buckler, ?, buckler};
+var setof_enum x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12;
+x1 := {amstel, buckler, coronita}
+x2 := {buckler, coronita, amstel}
+x3 := {buckler, buckler, amstel}
+x4 := {buckler, amstel, amstel}
+x5 := {buckler, amstel, desperados}
+x6 := {amstel, amstel, buckler, buckler}
+x7 := {buckler, coronita, buckler, amstel}
+x8 := {amstel, buckler}
+x9 := {buckler, coronita, buckler}
+x10 := {buckler, buckler, buckler}
+x11 := {coronita, amstel, amstel}
+x12 := {amstel, buckler, coronita, desperados}
+//match - in same order
+if (match(x1,setof_temp2)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match - in other orders
+if (match(x2,setof_temp2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x3,setof_temp2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x4,setof_temp2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x5,setof_temp2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x6,setof_temp3)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x7,setof_temp3)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match - too many elements
+if (match(x6,setof_temp2)) {setverdict(fail);}
+ else {setverdict(pass);}
+//no match - too few elements
+if (match(x8,setof_temp2)) {setverdict(fail);}
+ else {setverdict(pass);}
+//no match - element unmatched
+if (match(x9,setof_temp2)) {setverdict(fail);}
+ else {setverdict(pass);}
+if (match(x10,setof_temp2)) {setverdict(fail);}
+ else {setverdict(pass);}
+if (match(x11,setof_temp2)) {setverdict(fail);}
+ else {setverdict(pass);}
+if (match(x12,setof_temp3)) {setverdict(fail);}
+ else {setverdict(pass);}
+}
+
+testcase tsetofIntAnyorNoneMatch() runs on my_comp {
+//template setof_int setof_temp4 := {*};
+//template setof_int setof_temp5 := {1, *, 3};
+var setof_int x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10;
+//x0 := {omit}
+x1 := {}
+x2 := {1}
+x3 := {2}
+x4 := {2, 1}
+x5 := {3, 2, 1}
+x6 := {1, 3}
+x7 := {3, 1}
+x8 := {1, 2, 3}
+x9 := {3, 2, 1}
+x10 := {4, 3, 2, 1}
+ //match - matches everything
+ /*
+if (match(x0,setof_temp4)) {setverdict(pass);}
+ else {setverdict(fail);}
+ */
+if (match(x1,setof_temp4)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x2,setof_temp4)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x3,setof_temp4)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x4,setof_temp4)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x5,setof_temp4)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match - in same and reverse order
+if (match(x6,setof_temp5)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x7,setof_temp5)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match - with one or more anyvalues
+if (match(x8,setof_temp5)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x9,setof_temp5)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x10,setof_temp5)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase tsetofRecordofAnyorNoneMatch() runs on my_comp {
+// setof_recordof setof_temp6 := {*, {1,2}, {3}, *};
+var setof_recordof x1, x2, x3, x4, x5, x6, x7;
+x1 := {{1,2},{3}};
+x2 := {{3},{1,2}};
+x3 := {{2,1},{3}};
+x4 := {{1,2},{3},{1,2}};
+x5 := {{1,2,3},{1},{2},{3},{1,2},{2,3},{1,3}};
+x6 := {{1,2,3},{3},{2,3},{1,3},{3,3}};
+x7 := {{1,2}};
+//match in both order
+if (match(x1,setof_temp6)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x2,setof_temp6)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match - wrong order in the record
+if (not(match(x3,setof_temp6))) {setverdict(pass);}
+ else {setverdict(fail);}
+//match - use anyornone values
+if (match(x4,setof_temp6)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x5,setof_temp6)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match - no match for one of the elements
+if (not(match(x6,setof_temp6))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(match(x7,setof_temp6))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase tsetofSetofMatch() runs on my_comp {
+// setof_setof setof_temp7 := {{?,1}, {7,3}, ?, {5,*}};
+var setof_setof x1, x2, x3, x4, x5;
+x1 := {{1,1},{7,3},{8,9},{5}};
+x2 := {{7,6,5},{1,0},{3,7},{11}};
+x3 := {{5,7,3},{7,3},{},{1,5}};
+x4 := {{7,3},{1,2},{5}};
+x5 := {{1,1,1},{3,7},{2,3},{5,5}};
+//match - in the same order
+if (match(x1,setof_temp7)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match - in different order
+if (match(x2,setof_temp7)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x3,setof_temp7)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: too few elements
+if (not(match(x4,setof_temp7))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: first element unmatched
+if (not(match(x5,setof_temp7))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase tsetofSetofLengthMatch1() runs on my_comp {
+//template setof_setof setof_temp8 := {{1,*}, * length (4)};
+// Note: the interpretation of the asterisk with length restriction is
+// unspecified in the standard.
+// In our interpretation the asterisk matches exactly one element if it has
+// extra matching attributes (e.g. length restriction).
+// That is, * length(4) and ? length(4) are treated as equivalents.
+var setof_setof x1, x2, x3, x4, x5, x6, x7, x8;
+x1 := {{1},{1,1,1,1}};
+x2 := {{1,2,3,4},{5,1}};
+x3 := {{1,2,3},{1,2,3,4},{4,3,2,1}};
+x4 := {{5,1}};
+x5 := {{2,3,4,5}};
+x6 := {{1},{1,2},{1,2,3,4}};
+x8 := {{1},{1,2,3,4},{1,2}};
+x7 := {{1},{1,2}};
+//match - in same order
+if (match(x1,setof_temp8)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match - in different order
+if (match(x2,setof_temp8)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match - multiple fixed length elements
+if (not match(x3,setof_temp8)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match - no fixed length elements
+if (not match(x4,setof_temp8)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: element unmatched
+if (not match(x5,setof_temp8)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match - element of wrong length
+if (not(match(x6,setof_temp8))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(match(x8,setof_temp8))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(match(x7,setof_temp8))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase tsetofIntValueListMatch() runs on my_comp {
+//template setof_int setof_temp9 := ({1},{2,?},{3..5,?,?});
+var setof_int x1, x2, x3, x4, x5, x6, x7, x8, x9, x10;
+x1 := {1};
+x2 := {2,5};
+x3 := {3,3,3};
+x4 := {1,2,3};
+x5 := {2,1};
+x6 := {2};
+x7 := {1,2,6};
+x8 := {1,3};
+x9 := {1,2,2};
+x10 := {1,2,3,4};
+//match
+if (match(x1,setof_temp9)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x2,setof_temp9)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x3,setof_temp9)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x4,setof_temp9)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (match(x5,setof_temp9)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match
+if (not(match(x6,setof_temp9))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(match(x7,setof_temp9))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(match(x8,setof_temp9))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(match(x9,setof_temp9))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(match(x10,setof_temp9))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase tsetofSetofLengthMatch2() runs on my_comp {
+//template setof_setof setof_temp10 := {* length(2), * length(3), *};
+// See the note for testcase tsetofSetofLengthMatch1
+var setof_setof x1, x2, x3, x4, x5;
+x1 := {};
+x2 := {{1,2},{2,3},{1,2,3}};
+x3 := {{1}, {1,2}};
+x4 := {{1,2,3},{4,3}};
+x5 := {{},{}};
+//no match - empty set
+if (not match(x1,setof_temp10)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match - lengths are ok
+if (match(x2,setof_temp10)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: length too short
+if (not(match(x3,setof_temp10))) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: lengths are ok
+if (match(x4,setof_temp10)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: lengths are zero
+if (not(match(x5,setof_temp10))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+ testcase tsetofSuperset1() runs on my_comp {
+ template setof_int t1 := superset(1, 2, 3);
+ template setof_int t2 := superset(5, 4, 3, 2, 1);
+ template setof_int t3 := superset(5, 4, 3, 2, 1, 6);
+ template setof_int t4 := superset(5, 4, 3, 2, 1, ?);
+ template setof_int t5 := superset(5, 4, 3, 2, ?);
+ template setof_int t6 := superset(?, 5, 4, 3, 2);
+ template setof_int t7 := superset(?, 5, 4, 3, 2, *);
+ template setof_int t8 := superset(?, 5, 4, 3, *);
+ template setof_int t9 := superset(5, 4, 3, 2, 1, ?, *);
+ template setof_int t1a := superset(1, 7, 2, 3);
+ template setof_int t2a := superset(5, 4, 7, 3, 2, 1);
+ template setof_int t3a := superset(5, 4, 3, 7, 2, 1, 6);
+ template setof_int t4a := superset(5, 7, 4, 3, 2, 1, ?);
+ template setof_int t5a := superset(5, 4, 3, 2, ?, 7);
+ template setof_int t6a := superset(?, 5, 7, 4, 3, 2);
+ template setof_int t7a := superset(7, ?, 5, 4, 3, 2, *);
+ template setof_int t8a := superset(?, 5, 4, 7, 3, *);
+ template setof_int t9a := superset(5, 4, 3, 2, 7, 1, ?, *);
+ template setof_int t10 := superset(?, ?, ?, ?, ?, ?);
+ template setof_int t11 := superset(?, ?, ?, ?, ?);
+
+ if(match(setof_const1, t1)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t3)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t4)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t5)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t6)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t7)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t8)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t9)) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(not match(setof_const1, t1a)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t2a)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t3a)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t4a)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t5a)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t6a)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t7a)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t8a)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t9a)) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(not match(setof_const1, t10)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t11)) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ /* --- */
+
+ template setof_setof tt1 := superset(t1);
+ template setof_setof tt2 := superset(t2, superset(1));
+ template setof_setof tt3 := superset(t5, superset(1), superset(1));
+ template setof_setof tt4 := superset(t6, superset(1), superset(1, 0));
+ template setof_setof tt5 := superset(t7, superset(1), superset(1, 2));
+ template setof_setof tt6 := superset(t7, superset(1), t3);
+
+ if(match(setof_const5, tt1)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const5, tt2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const5, tt3)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const5, tt4)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const5, tt5)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const5, tt6)) {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+ testcase tsetofSuperset2() runs on my_comp {
+ template setof_enum t1 := superset(buckler);
+ template setof_enum t2 := superset(coronita);
+ template setof_enum t3 := superset(coronita, buckler);
+ template setof_enum t4 := superset(coronita, amstel);
+
+ if(not match(setof_const2, t1)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const2, t2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const2, t3)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const2, t4)) {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+ testcase tsetofSubset1() runs on my_comp {
+ template setof_int t1 := subset(1, 2, 3);
+ template setof_int t2 := subset(1, 2, 3, 4, 5, 6);
+ template setof_int t3 := subset(6, 5, 4, 3, 2, 1);
+ template setof_int t4 := subset(?);
+ template setof_int t5 := subset(*);
+ template setof_int t6 := subset(?, ?, ?, ?);
+ template setof_int t7 := subset(?, ?, ?, ?, ?);
+ template setof_int t8 := subset(?, ?, ?, ?, ?, ?);
+ template setof_int t9 := subset(?, ?, ?, ?, *);
+ template setof_int t10 := subset(2, 3, 4, 5, 6);
+ template setof_int t11 := subset(2, 3, 4, 5, 6, ?);
+ template setof_int t12 := subset(2, 3, 4, 5, 6, *);
+ template setof_int t13 := subset(3, 4, 5, 6, ?);
+
+ if(not match(setof_const1, t1)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t3)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t4)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t5)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t6)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t7)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t8)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t9)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t10)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t11)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const1, t12)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const1, t13)) {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+ testcase tsetofSubset2() runs on my_comp {
+ template setof_enum t1 := subset(buckler);
+ template setof_enum t2 := subset(coronita);
+ template setof_enum t3 := subset(coronita, buckler);
+ template setof_enum t4 := subset(coronita, amstel);
+ template setof_enum t5 := subset(coronita, buckler, amstel);
+
+ if(not match(setof_const2, t1)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const2, t2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(not match(setof_const2, t3)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const2, t4)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if(match(setof_const2, t5)) {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+control {
+execute(setofIntAssign());
+execute(setofIntEq());
+execute(setofSetofEq());
+
+execute(tsetofIntSpecValueMatch());
+execute(tsetofEnumAnyValueMatch());
+execute(tsetofIntAnyorNoneMatch());
+execute(tsetofRecordofAnyorNoneMatch());
+execute(tsetofSetofMatch());
+execute(tsetofSetofLengthMatch1());
+execute(tsetofIntValueListMatch());
+execute(tsetofSetofLengthMatch2());
+ execute(tsetofSuperset1());
+ execute(tsetofSuperset2());
+ execute(tsetofSubset1());
+ execute(tsetofSubset2());
+}
+}
diff --git a/Regression_Test_java/src/TsetofOper.ttcn b/Regression_Test_java/src/TsetofOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..c2cd405e74d57ebecc109a045637c19e2a57af55
--- /dev/null
+++ b/Regression_Test_java/src/TsetofOper.ttcn
@@ -0,0 +1,1098 @@
+/******************************************************************************
+ * 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
+ * Beres, Szabolcs
+ * Godar, Marton
+ * Kovacs, Ferenc
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TsetofOper {
+// ********** Type definitions *********************
+type component setofOper_mycomp {};
+type enumerated setofOper_myenum {xx1,xx2,xx3};
+type record setofOper_trecord {
+ integer x1 optional,
+ float x2 };
+type record of octetstring setofOper_trecof;
+type set setofOper_tset {
+ integer x1,
+ float x2 optional };
+type set of charstring setofOper_tsetof;
+type union setofOper_tunion {
+ integer x1,
+ float x2 };
+type set of integer setofOper_mysetof1; // set of basic types
+type set of setofOper_myenum setofOper_mysetof2; // set of enum
+type set of setofOper_trecord setofOper_mysetof3; // set of record
+type set of setofOper_trecof setofOper_mysetof4; // set of record of
+type set of setofOper_tset setofOper_mysetof5; // set of set
+type set of setofOper_tsetof setofOper_mysetof6; // set of set of
+type set of setofOper_tunion setofOper_mysetof7; // set of union
+// *************** Constanst ***********************
+const setofOper_trecord setofOper_temp1:={ x1:=omit, x2:=3.4 };
+const setofOper_trecof setofOper_temp2:={ 'AF12'O };
+const setofOper_tset setofOper_temp3:={ x1:=234, x2:=1.9};
+const setofOper_tsetof setofOper_temp4:={"f","8"};
+const setofOper_tunion setofOper_temp5:={ x2:=1.3 };
+const setofOper_mysetof1 setofOper_const1:={ 1,2 } //set of basic types
+const setofOper_mysetof2 setofOper_const2:={ xx2, xx1 }
+const setofOper_mysetof3 setofOper_const4:={ //set of record
+ { x1:=1, x2:=1.2 },setofOper_temp1 };
+const setofOper_mysetof4 setofOper_const6:={ //set of record of
+ { '12AB'O, 'CD12'O }, setofOper_temp2 };
+const setofOper_mysetof5 setofOper_const8:={ //set of set
+ { x1:=2, x2:=1.3}, setofOper_temp3 };
+const setofOper_mysetof6 setofOper_const10:={ //set of set of
+ {"a","b"}, setofOper_temp4 }; //{"f","8"},
+const setofOper_mysetof7 setofOper_const12:={ //set of union
+ { x1 :=3 }, setofOper_temp5 }; //{ x2:=1.3 }
+
+testcase setofAssign() runs on setofOper_mycomp{
+ var setofOper_mysetof1 x1:={ 12,34} //set of basic types
+ var setofOper_mysetof1 x2,x3,x4;
+ x2:={ 32, 12 };
+ x3:={32};
+ x3:={32,12};
+ x4:={};
+ if (x1[0]==12) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+ if (x1[1]==34) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[0]==32) {setverdict(pass);} //later
+ else {setverdict(fail);}
+ if (x2[1]==12) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x3[0]==32) {setverdict(pass);} //later, change of size
+ else {setverdict(fail);}
+ if (x3[1]==12) {setverdict(pass);}
+ else {setverdict(fail);}
+ //if (x4=={}) {setverdict(pass);} // empty set of
+ // else {setverdict(fail);}
+}
+
+testcase setofAssignEnum() runs on setofOper_mycomp{
+ var setofOper_mysetof2 x1:={ xx2 } //set of enum
+ var setofOper_mysetof2 x2;
+ x2:={xx2,xx1};
+ //at declaration
+ if (x1[0]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+ //later
+ if (x2[0]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[1]==xx1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofAssignRec() runs on setofOper_mycomp{
+ var setofOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+ var setofOper_mysetof3 x1:={ //set of record
+ { x1:=1, x2:=1.2 }, temp1 };
+ var setofOper_mysetof3 x2;
+ x2:={ { x1:=1, x2:=1.2 }, temp1 };
+ if (x1[0].x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+ if (x1[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x1[1]==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[0].x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+ if (x2[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ispresent(x2[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[1].x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofAssignRecof() runs on setofOper_mycomp{
+ var setofOper_trecof temp2:={'AF12'O};
+ var setofOper_mysetof4 x1:={ //set of record of
+ { '12AB'O, 'CD12'O }, temp2 };
+ var setofOper_mysetof4 x2;
+ x2:={ { '12AB'O, 'CD12'O }, temp2 };
+ if (x1[0][0]=='12AB'O) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+ if (x1[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x1[1]==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[0][0]=='12AB'O) {setverdict(pass);} //later
+ else {setverdict(fail);}
+ if (x2[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[1][0]=='AF12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofAssignSet() runs on setofOper_mycomp{
+ var setofOper_tset temp1:={ x1:=2, x2:=omit };
+ var setofOper_mysetof5 x1:={ //set of set
+ { x1:=1, x2:=1.2 }, temp1 };
+ var setofOper_mysetof5 x2;
+ x2:={ { x1:=1, x2:=1.2 }, temp1 };
+ if (x1[0].x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+ if (x1[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x1[1]==temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[0].x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+ if (x2[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[1].x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ispresent(x2[1].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofAssignSetof() runs on setofOper_mycomp{
+ var setofOper_tsetof temp2:={"a","7"};
+ var setofOper_mysetof6 x1:={ //set of set of
+ { "1", "a" }, temp2 };
+ var setofOper_mysetof6 x2;
+ x2:={ { "1", "a" }, temp2 };
+ if (x1[0][0]=="1") {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+ if (x1[0][1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x1[1]==temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[0][0]=="1") {setverdict(pass);} //later
+ else {setverdict(fail);}
+ if (x2[0][1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[1][0]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[1][1]=="7") {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofAssignUnion() runs on setofOper_mycomp{
+ var setofOper_tunion temp5 := {x2:=1.3}
+ var setofOper_mysetof7 x1:={ //set of union
+ { x1 :=3 }, temp5 }; //{ x2:=1.3
+ var setofOper_mysetof7 x2;
+ x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
+ if (x1[0].x1==3) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+ if (ischosen(x1[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ischosen(x1[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x1[1]==temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[0].x1==3) {setverdict(pass);} //later
+ else {setverdict(fail);}
+ if (ischosen(x2[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ischosen(x2[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (ischosen(x2[1].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ischosen(x2[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofAssignElem() runs on setofOper_mycomp{
+ var setofOper_mysetof1 x1,x2,x3,x4,x5; //set of basic types
+ x1:={ 3, 2 };
+ x2:={ 1, 2 };
+ x3:=x2;
+ x4:=x2;
+ x5:={2};
+ x2[0]:=3; //change element to value
+ x3[0]:=x1[0]; //change element to element
+ x4[2]:=2; // add element
+ x5[2]:=3; // out of order
+ if (x1[1]==2) {setverdict(pass);} //accessing individual element
+ else {setverdict(fail);}
+ if (x2[0]==3) {setverdict(pass);} // change element to value
+ else {setverdict(fail);}
+ if (x2[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x3[0]==3) {setverdict(pass);} // change element to element
+ else {setverdict(fail);}
+ if (x3[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x4[0]==1) {setverdict(pass);} // add element
+ else {setverdict(fail);}
+ if (x4[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x4[2]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x5[2]==3) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase setofAssignElemEnum() runs on setofOper_mycomp{
+ var setofOper_mysetof2 x1:={ xx1, xx2 }; //set of enumerated
+ var setofOper_mysetof2 x2, x3;
+ x2:={ xx1, xx2 }
+ x1[0]:=xx3; //change element
+ x2[2]:=xx3; // add element
+ x3[2]:=xx3; // out of order
+ if (x1[0]==xx3) {setverdict(pass);} // change element
+ else {setverdict(fail);}
+ if (x1[1]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[0]==xx1) {setverdict(pass);} // add element
+ else {setverdict(fail);}
+ if (x2[1]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[2]==xx3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x3[2]==xx3) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase setofAssignElemRec() runs on setofOper_mycomp{
+ var setofOper_mysetof3 x1,x2,x3; //set of record
+ x1:={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
+ x2:=x1;
+ x1[0].x1:=2;
+ //temp1.x1:=3;
+ x1[1].x1:=3;
+ x2[2]:= {x1:=2, x2:=1.3}; // add element
+ x3[1]:= {x1:=2, x2:=1.3}; //out of order
+ if (x1[0].x1==2) {setverdict(pass);} // change element
+ else {setverdict(fail);}
+ if (x1[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x1[1].x1==3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x1[1].x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[0].x1==1) {setverdict(pass);} //add element
+ else {setverdict(fail);}
+ if (x2[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ispresent(x2[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[1].x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[2].x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[2].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x3[1].x1==2) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+ if (x3[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase setofAssignElemRecof() runs on setofOper_mycomp{
+ var setofOper_mysetof4 x1,x2,x3; //set of record of
+ x1:={ { '12AB'O, 'CD12'O }, { 'ABCD'O } };
+ x2:=x1;
+ x1[0][1]:='34AB'O; //change element
+ x2[2]:={ '1234'O}; //add element
+ x3[2]:={'12CD'O}; //out of order
+ if (x1[0][0]=='12AB'O) {setverdict(pass);} // change element
+ else {setverdict(fail);}
+ if (x1[0][1]=='34AB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x1[1][0]=='ABCD'O) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[0][0]=='12AB'O) {setverdict(pass);} // add element
+ else {setverdict(fail);}
+ if (x2[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[1][0]=='ABCD'O) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[2][0]=='1234'O) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x3[2][0]=='12CD'O) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+}
+
+testcase setofAssignElemSet() runs on setofOper_mycomp{
+ var setofOper_mysetof5 x1,x2,x3 //set of set
+ x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
+ x2:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit }};
+ x1[0].x2:=3.4; //change element
+ x2[2]:={ x1:=2, x2:=1.3 }; // add element
+ x3[2]:={ x1:=2, x2:=1.3 }; // out of order
+ if (x1[0].x1==1) {setverdict(pass);} //change element
+ else {setverdict(fail);}
+ if (x1[0].x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x1[1].x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ispresent(x1[1].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[0].x1==1) {setverdict(pass);} //add element
+ else {setverdict(fail);}
+ if (x2[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[1].x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ispresent(x2[1].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[2].x1==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[2].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x3[2].x1==2) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+ if (x3[2].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofAssignElemSetof() runs on setofOper_mycomp{
+ var setofOper_tsetof temp2:={"a","7"};
+ var setofOper_mysetof6 x1,x2,x3; //set of set of
+ x1:={ { "1" }, {"a","7"}};
+ x2:={ { "1" }, {"a","7"}};
+ x1[0][0]:="h"; // change element
+ x2[2]:={"2"}; //add element
+ x3[2]:={"2"}; //out of order
+ if (x1[0][0]=="h") {setverdict(pass);} //change element
+ else {setverdict(fail);}
+ if (x1[1][0]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x1[1][1]=="7") {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[0][0]=="1") {setverdict(pass);} //add element
+ else {setverdict(fail);}
+ if (x2[1][0]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[1][1]=="7") {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[2][0]=="2") {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x3[2][0]=="2") {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase setofAssignElemUnion() runs on setofOper_mycomp{
+ var setofOper_tunion temp5 := {x2:=1.3}
+ var setofOper_mysetof7 x1,x2,x3; //set of union
+ x1:={ {x1 :=3 }, {x2:=1.3} };
+ x2:={ {x1 :=3 }, {x2:=1.3} };
+ x1[0].x2:=3.4; //change element
+ x2[2]:={ x2:=1.4}; // add element
+ x3[2]:={ x2:=1.4}; // out of order
+ if (x1[0].x2==3.4) {setverdict(pass);} //change element
+ else {setverdict(fail);}
+ if (ischosen(x1[0].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ischosen(x1[0].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x1[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (ischosen(x1[1].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ischosen(x1[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[0].x1==3) {setverdict(pass);} //add element
+ else {setverdict(fail);}
+ if (ischosen(x2[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ischosen(x2[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (ischosen(x2[1].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ischosen(x2[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x2[2].x2==1.4) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (ischosen(x2[2].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ischosen(x2[2].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x3[2].x2==1.4) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+ if (ischosen(x3[2].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ischosen(x3[2].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofConst() runs on setofOper_mycomp{
+ const setofOper_mysetof1 const1:={1,2,3} //set of basic types
+ if (setofOper_const1[0]==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+ if (setofOper_const1[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const1[0]==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+ if (const1[1]==2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const1[2]==3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofConstEnum() runs on setofOper_mycomp{
+ const setofOper_mysetof2 const1:={xx1,xx2,xx3} //set of enumerated
+ if (setofOper_const2[0]==xx2) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+ if (setofOper_const2[1]==xx1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const1[0]==xx1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+ if (const1[1]==xx2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const1[2]==xx3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofConstRec() runs on setofOper_mycomp{
+ const setofOper_mysetof3 const4:={ //set of record
+ { x1:=1, x2:=1.2 }, setofOper_temp1 };
+ if (setofOper_const4[0].x1==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+ if (setofOper_const4[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (setofOper_const4[1]==setofOper_temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const4[0].x1==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+ if (const4[0].x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const4[1]==setofOper_temp1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofConstRecof() runs on setofOper_mycomp{
+ const setofOper_mysetof4 const6:={ //set of record of
+ { '12AB'O, 'CD12'O }, setofOper_temp2 };
+ if (setofOper_const6[0][0]=='12AB'O) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+ if (setofOper_const6[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (setofOper_const6[1]==setofOper_temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const6[0][0]=='12AB'O) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+ if (const6[0][1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const6[1]==setofOper_temp2) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofConstSet() runs on setofOper_mycomp{
+ const setofOper_mysetof5 const8:={ //set of set
+ { x1:=2, x2:=1.3}, setofOper_temp3 };
+ if (setofOper_const8[0].x1==2) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+ if (setofOper_const8[0].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (setofOper_const8[1]==setofOper_temp3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const8[0].x1==2) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+ if (const8[0].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const8[1]==setofOper_temp3) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofConstSetof() runs on setofOper_mycomp{
+ const setofOper_mysetof6 const10:={ //set of set of
+ {"a","b"}, {"f","8"} };
+ if (setofOper_const10[0][0]=="a") {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+ if (setofOper_const10[0][1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+ if (setofOper_const10[1]==setofOper_temp4) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const10[0][0]=="a") {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+ if (const10[0][1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const10[1][0]=="f") {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const10[1][1]=="8") {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofConstUnion() runs on setofOper_mycomp{
+ const setofOper_mysetof7 const12:={ //set of union
+ { x1 :=3 }, { x2:=1.3 } };
+ if (setofOper_const12[0].x1==3) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+ if (ischosen(setofOper_const12[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ischosen(setofOper_const12[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (setofOper_const12[1]==setofOper_temp5) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const12[0].x1==3) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+ if (ischosen(const12[0].x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ischosen(const12[0].x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (const12[1].x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (ischosen(const12[1].x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(ischosen(const12[1].x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofConstComp() runs on setofOper_mycomp{
+ const setofOper_mysetof1 x1:={ 1,2,3 };
+ const setofOper_mysetof1 x2:={ 1,2,3 };
+ const setofOper_mysetof1 x3:={ 1,2 };
+ const setofOper_mysetof1 x4:={ 3,1,2 };
+ if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x4==x2) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+ if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x4!=x2)) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase setofComp() runs on setofOper_mycomp{
+ var setofOper_mysetof1 x1,x2,x3,x4; //set of basic types
+ x1:={ 1,2,3 };
+ x2:={ 1,2,3 };
+ x3:={ 1,2 };
+ x4:={ 3,1,2 };
+ if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x4==x2) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+ if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x4!=x2)) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase setofCompEnum() runs on setofOper_mycomp{
+ var setofOper_mysetof2 x1,x2,x3,x4; //set of enumerated
+ x1:={ xx1,xx2,xx3 };
+ x2:={ xx1,xx2,xx3 };
+ x3:={ xx1,xx2 };
+ x4:={xx3,xx2,xx1};
+ if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x4==x2) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+ if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x4!=x2)) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase setofCompRec() runs on setofOper_mycomp{
+ var setofOper_mysetof3 x1,x2,x3,x4; // set of record
+ x1 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
+ x2 :={ { x1:=1, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
+ x3 :={ { x1:=2, x2:=1.2 }, { x1:=omit, x2:=3.4 } };
+ x4 :={ { x1:=omit, x2:=3.4 }, { x1:=1, x2:=1.2 } };
+ if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x4==x2) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+ if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x4!=x2)) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+
+testcase setofCompRecof() runs on setofOper_mycomp{
+ var setofOper_mysetof4 x1,x2,x3,x4; //set of record of
+ x1:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
+ x2:={ { '12AB'O, 'CD12'O }, {'AF12'O} };
+ x3:={ { '12AB'O }, {'AF12'O} };
+ x4:={ {'AF12'O}, { '12AB'O, 'CD12'O } };
+ if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x4==x2) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+ if (x2!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x4!=x2)) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+}
+
+testcase setofCompSet() runs on setofOper_mycomp{
+ var setofOper_tset temp1:={ x1:=2, x2:=omit };
+ var setofOper_mysetof5 x1,x2,x3,x4; //set of set
+ x1:={ { x1:=1, x2:=1.2 }, { x1:=2, x2:=omit } };
+ x2:={ { x2:=1.2, x1:=1 }, { x1:=2, x2:=omit }};
+ x3:={ { x1:=1, x2:=1.2 } };
+ x4:={ { x1:=2, x2:=omit }, { x2:=1.2, x1:=1 } };
+ if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x2==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x4==x2) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+ if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x4!=x2)) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+}
+
+testcase setofCompSetof() runs on setofOper_mycomp{
+ var setofOper_tsetof temp2:={"a","7"};
+ var setofOper_mysetof6 x1,x2,x3,x4; //set of set of
+ x1:={ { "1", "a" }, temp2 };
+ x2:={ { "1", "a" }, {"a","7"} };
+ x3:={ { "1", "a" } };
+ x4:={ {"a","7"}, { "1", "a" } };
+ if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x2==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x4==x2) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+ if (x1!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x4!=x2)) {setverdict(pass);} // out of order
+ else {setverdict(fail);}
+}
+
+testcase setofCompUnion() runs on setofOper_mycomp{
+ var setofOper_tunion temp5 := {x2:=1.3}
+ var setofOper_mysetof7 x1,x2,x3,x4; //set of union
+ x1:={ { x1 :=3 }, { x2:=1.3 } };
+ x2:={ { x1 :=3 }, temp5 }; //{ x2:=1.3 }
+ x3:={ { x2 :=3.9 },temp5 }; //{ x2:=1.3 }
+ x4:={ { x2:=1.3 }, { x1 :=3 } };
+ if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1==x3)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x4==x2) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+ if (x2!=x3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not(x4!=x2)) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+}
+
+//TR HP50388:
+testcase setofCompUnbound() runs on setofOper_mycomp{
+ var setofOper_mysetof1 x1,x2,x3,x4;
+ x1 := {[3] := 4};
+ x2 := {[3] := 4};
+ x3 := {-,-,-,4};
+ x4 := {-,4,-,-};
+ if (x1 == x2) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x1 == x3) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x1 == x4) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofListOperator() runs on setofOper_mycomp{
+ var setofOper_mysetof1 x1:={1,2};
+ var setofOper_mysetof1 x2,x3,x4,x5,x6; //set of basic types
+ var setofOper_mysetof1 res1, res2, res3, res4, res5;
+ x2:={ 1, 2 };
+ x3:={1};
+ x4:={1};
+ x4[1]:=3;
+ x5:={};
+ x6[2]:=1;
+ res1 := x1 & x2;
+ res2 := x1 & x3;
+ res3 := x2 & x3 & x5;
+ res4 := x3 & x4;
+ res5 := x1 & {};
+ if (res1 == {1,2,1,2}) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (res2 == {1,2,1}) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (res3 == {1,2,1}) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (res4 == {1,1,3}) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (res5 == {1,2}) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofRotateOperators() runs on setofOper_mycomp{
+ var setofOper_mysetof1 x1:={1,2,3,4,5};
+ var setofOper_mysetof1 x2,x3,x4,x5,x6,x7; //set of basic types
+ x2 := x1 <@ 1;
+ x3 := x1 <@ 10;
+ x4 := x1 <@ 3 <@ 2;
+ x5 := x1 @> 1;
+ x6 := x1 @> 10;
+ x7 := x1 @> 3 @> 2;
+ if (x2 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x3 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x4 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x5 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x6 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+ if (x7 == x1) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofLengthof() runs on setofOper_mycomp{
+// lengthof returns the sequential number of the last initialized element of the set of list type
+ var setofOper_mysetof1 x1:={1,2};
+ var setofOper_mysetof1 x2,x3,x4,x5,x6; //set of basic types
+ x2:={ 1, 2 };
+ x3:={1};
+ x4:={1};
+ x3:={1,2}; //change size by assignment
+ x4[1]:=3; //change size by adding element
+ x5:={}; //empty set of
+ x6[2]:=1; //out of order
+ if (lengthof(x1)==2) {setverdict(pass);} //assignment at declaration
+ else {setverdict(fail);}
+ if (lengthof(x2)==2) {setverdict(pass);} //assignment later
+ else {setverdict(fail);}
+ if (lengthof(x3)==2) {setverdict(pass);} //change size by assignment
+ else {setverdict(fail);}
+ if (lengthof(x4)==2) {setverdict(pass);} //change size by adding element
+ else {setverdict(fail);}
+ if (lengthof(x5)==0) {setverdict(pass);} //empty set of
+ else {setverdict(fail);}
+ if (lengthof(x6)==3) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+}
+
+testcase setofSizeof() runs on setofOper_mycomp{
+ var setofOper_mysetof1 x1:={1,2};
+ var setofOper_mysetof1 x2,x3,x4,x5,x6; //set of basic types
+ x2:={ 1, 2 };
+ x3:={1};
+ x4:={1};
+ x3:={1,2}; //change size by assignment
+ x4[1]:=3; //change size by adding element
+ x5:={}; //empty set of
+ x6[2]:=1; //out of order
+ if (sizeof(x1)==2) {setverdict(pass);} //assignment at declaration
+ else {setverdict(fail);}
+ if (sizeof(x2)==2) {setverdict(pass);} //assignment later
+ else {setverdict(fail);}
+ if (sizeof(x3)==2) {setverdict(pass);} //change size by assignment
+ else {setverdict(fail);}
+ if (sizeof(x4)==2) {setverdict(pass);} //change size by adding element
+ else {setverdict(fail);}
+ if (sizeof(x5)==0) {setverdict(pass);} //empty set of
+ else {setverdict(fail);}
+ if (sizeof(x6)==3) {setverdict(pass);} //out of order
+ else {setverdict(fail);}
+}
+
+testcase setofReplace() runs on setofOper_mycomp{
+ var setofOper_mysetof1 x1:={1,2,3,4,5};
+ var setofOper_mysetof1 a:={8,8,8};
+ var setofOper_mysetof1 x2;
+ x2 := replace(x1,2,3,a);
+ if (x2 == {1,2,8,8,8}) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase setofSubstr() runs on setofOper_mycomp{
+ var setofOper_mysetof1 x1:={1,2,3,4,5};
+ var setofOper_mysetof1 x2;
+ x2 := substr(x1,2,3);
+ if (x2 == {3,4,5}) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+type record intsetrec { setofOper_mysetof1 a }
+type set of intsetrec intsetreclist
+
+testcase setofIsvalue() runs on setofOper_mycomp {
+ var setofOper_mysetof1 v_def;
+ var setofOper_mysetof1 v_empty := {-,-,-,-,-,-,-,-,-,-};
+ var setofOper_mysetof1 v_full := {1,2,3,4,5,6,7,8,9,10}
+
+ if ( isvalue(v_def) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_empty) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_empty[1]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_empty[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_full) ) { setverdict(pass); } else { setverdict(fail); };
+
+ v_def[1] := 3;
+
+ if ( isvalue(v_def[1]) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v_def) ) { setverdict(fail); } else { setverdict(pass); };
+
+
+ template intsetreclist ist1 := { { a := { 1, 2, 3 } } };
+ template intsetreclist ist2 modifies ist1 := { { a := { 1, 2, -, -, -, 100 } } }
+ template intsetrec istt1 := { a := { 1, 2, 3 } }
+ template intsetrec istt2 modifies istt1 := { a := { 1, 2, -, -, -, 100 } }
+
+ if (isvalue (ist1)) { setverdict ( pass );
+ } else { setverdict ( fail ); }
+ if (isvalue (ist2)) { setverdict ( fail ); }
+ else { setverdict(pass); }
+ if (isvalue (istt1)) { setverdict ( pass );}
+ else { setverdict ( fail ); }
+ if (isvalue (istt2)) { setverdict ( fail ); }
+ else { setverdict(pass); }
+}
+
+testcase setofIsvalue2() runs on setofOper_mycomp {
+ var setofOper_mysetof1 v;
+ if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
+
+ v[3] := 3;
+ if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
+
+ v[2] := 2;
+ if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
+
+ v[1] := 1;
+ if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
+
+ v[0] := 0;
+ if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); };
+
+ v[4] := 4;
+ if ( isvalue(v) ) { setverdict(pass); } else { setverdict(fail); };
+
+ v[6] := 6; // there is now a hole at 5
+ if ( isvalue(v) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+testcase setofIsbound() runs on setofOper_mycomp {
+ var setofOper_mysetof1 v_def;
+ var setofOper_mysetof1 v_empty := {-,-,-,-,-,-,-,-,-,-};
+ var setofOper_mysetof1 v_full := {1,2,3,4,5,6,7,8,9,10}
+
+ if ( isbound(v_def) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(v_empty) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(v_empty[1]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(v_empty[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(v_full) ) { setverdict(pass); } else { setverdict(fail); };
+
+ v_def[1] := 3;
+
+ if ( isbound(v_def) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(v_def[1]) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(v_def[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(v_def[10]) ) { setverdict(fail); } else { setverdict(pass); };
+
+
+ template intsetreclist ist1 := { { a := { 1, 2, 3 } } };
+ template intsetreclist ist2 modifies ist1 := { { a := { 1, 2, -, -, -, 100 } } }
+ template intsetrec istt1 := { a := { 1, 2, 3 } }
+ template intsetrec istt2 modifies istt1 := { a := { 1, 2, -, -, -, 100 } }
+
+ if (isbound (ist1)) { setverdict(pass); } else { setverdict(fail); };
+ if (isbound (ist2)) { setverdict(pass); } else { setverdict(fail); };
+ if (isbound (istt1)) { setverdict(pass); } else { setverdict(fail); };
+ if (isbound (istt2)) { setverdict(pass); } else { setverdict(fail); };
+}
+
+testcase setofCompConst() runs on setofOper_mycomp{
+ const setofOper_mysetof1 c_s1 := {1,2,3,4};
+ const setofOper_mysetof1 c_s2 := {4,3,2,1};
+ const setofOper_mysetof1 c_s3 := {1,3,2,4};
+ const setofOper_mysetof1 c_s4 := {1,2,3,4,5};
+ const setofOper_mysetof1 c_s5 := {0,1,2,3,4};
+ const setofOper_mysetof1 c_s6 := {0,1,2,3,4,5}
+
+ const setofOper_mysetof1 c_s1_ind := {[0] := 1,[1] := 2,[2] := 3, [3] := 4};
+ const setofOper_mysetof1 c_s2_ind := {[0] := 1,[3] := 4,[2] := 3, [1] := 2};
+ const setofOper_mysetof1 c_s3_ind := {[0] := 2,[3] := 1,[2] := 3, [1] := 4};
+
+ var setofOper_mysetof1 vl_s1 := {1,2,3,4};
+
+ if(c_s1 == c_s1) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s1 == {1,2,3,4}) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s1 == {[0] := 1,[1] := 2,[2] := 3, [3] := 4}) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s1 == c_s1_ind) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s1_ind == c_s2_ind) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s1_ind == c_s3_ind) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s1 == c_s3_ind) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s2_ind == c_s3_ind) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s1 == vl_s1) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s1 == c_s2) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s1 == c_s3) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s1 != c_s4) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s1 != c_s5) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s1 != c_s6) {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if(c_s5 != c_s6) {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+type set length(5) of set length(6) of charstring StringSetArray length(12)
+type set length(4) of charstring MySetof1 length(2)
+type set of charstring MySetof2 ("a", "aa", "aaa", "aaaa") length(2)
+type set length(2) of charstring MySetof3 ("a", "aa", "aaa", "aaaa")
+type set length(2) of charstring MySetof4 ("a", "aa", "aaa", "aaaa") length(2)
+// TODO: Add additional subtypes here.
+type MySetof2 MySetof5
+type MySetof3 MySetof6
+type MySetof4 MySetof7
+type set of record { charstring id length(2), charstring val length(2) } GenericParameters1
+type GenericParameters1[-] GenericParameters2 ({"aa", "aa"})
+type GenericParameters1[-] GenericParameters3 ({"aa", "aa"})
+// FATAL_ERROR() with R8B: `const GenericParameters1[-] c_pars1 := {c_mysetof6[0], valueof(t_mysetof7[0])}'.
+// Possibly the same FATAL_ERROR(): `template MySetof2 t_mysetof8 := {"aa", t_mysetof7[0]} length(2)'.
+// `MySetof2' doesn't have a subtype? `type MySetof2 MySetof8 (MySetof2)'
+type MySetof3 MySetof8 (MySetof3, MySetof3, MySetof3)
+
+const MySetof2 c_mysetof1 := {}
+const MySetof2 c_mysetof2 := {"aa", "aa"}
+const MySetof2 c_mysetof3 := {c_mysetof2[0], c_mysetof2[1]}
+const MySetof3 c_mysetof4 := {"a", "aa"}
+const MySetof3 c_mysetof5 := {c_mysetof4[0], c_mysetof4[1]}
+const MySetof4 c_mysetof6 := {"aa", "aa"}
+const MySetof4 c_mysetof7 := {c_mysetof6[0], c_mysetof6[1]}
+
+template MySetof2 t_mysetof1 := {}
+template MySetof2 t_mysetof2 := {"aa", "aa"}
+template MySetof2 t_mysetof3 := c_mysetof2
+template MySetof3 t_mysetof4 := {"a", "aa"}
+template MySetof3 t_mysetof5 := c_mysetof5
+template MySetof4 t_mysetof6 := {"aa", "aa"}
+template MySetof4 t_mysetof7 := c_mysetof7
+template MySetof2 t_mysetof8 := {"aa", c_mysetof7[0]} length(2)
+template MySetof8 t_mysetof9 := {"aa" & "aa", "aa"}
+
+//testcase setofSubtypes() runs on setofOper_mycomp {
+// var template MySetof1 vt_mysetof1 := {"AA", "AB", "BA", "BB"}
+// var MySetof1 v_mysetof1 := {"AA", "AB", "BA", "BB"}
+// // TITAN compiles this.
+// if (substr(v_mysetof1, 0, 2) == {"AA", "AB"} and {"BA", "BB"} == substr(valueof(vt_mysetof1), 2, 2)) { setverdict(pass) }
+// else { setverdict(fail) }
+//}
+
+control {
+ const setofOper_trecord cl_temp1:={ x1:=omit, x2:=3.4 }; //constant in control part
+ const setofOper_trecof cl_temp2:={ 'AF12'O };
+ const setofOper_tset cl_temp3:={ x1:=234, x2:=1.9};
+ const setofOper_tsetof cl_temp4:={"f","8"};
+ const setofOper_tunion cl_temp5:={ x2:=1.3 };
+ var setofOper_trecord vl_temp1; //variable in control part
+ var setofOper_trecof vl_temp2;
+ var setofOper_tset vl_temp3;
+ var setofOper_tsetof vl_temp4;
+ var setofOper_tunion vl_temp5;
+
+ execute(setofAssign());
+ execute(setofAssignEnum());
+ execute(setofAssignRec());
+ execute(setofAssignRecof());
+ execute(setofAssignSet());
+ execute(setofAssignSetof());
+ execute(setofAssignUnion());
+ execute(setofAssignElem());
+ execute(setofAssignElemEnum());
+ execute(setofAssignElemRec());
+ execute(setofAssignElemRecof());
+ execute(setofAssignElemSet());
+ execute(setofAssignElemSetof());
+ execute(setofAssignElemUnion());
+ execute(setofConst());
+ execute(setofConstEnum());
+ execute(setofConstRec());
+ execute(setofConstRecof());
+ execute(setofConstSet());
+ execute(setofConstSetof());
+ execute(setofConstUnion());
+ execute(setofConstComp());
+ execute(setofComp());
+ execute(setofCompConst());
+ execute(setofCompEnum());
+ execute(setofCompRec());
+ execute(setofCompRecof());
+ execute(setofCompSet());
+ execute(setofCompSetof());
+ execute(setofCompUnion());
+ execute(setofCompUnbound());
+ execute(setofListOperator());
+ execute(setofRotateOperators());
+ execute(setofLengthof());
+ execute(setofSizeof());
+ execute(setofReplace());
+ execute(setofSubstr());
+ execute(setofIsvalue());
+ execute(setofIsvalue2());
+ execute(setofIsbound());
+
+
+// execute(setofSubtypes());
+
+
+}
+
+}
diff --git a/Regression_Test_java/src/TtemplateAnytype.ttcn b/Regression_Test_java/src/TtemplateAnytype.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..52298785ecc27d2743582f171132ebec102c55d6
--- /dev/null
+++ b/Regression_Test_java/src/TtemplateAnytype.ttcn
@@ -0,0 +1,185 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ * Szabados, Kristof
+ *
+ ******************************************************************************/
+module TtemplateAnytype {
+type component templateAnytype_mycomp {};
+type anytype templateAnytype_myAnytype /*{
+ integer f1,
+ float f2 }*/;
+type record templateAnytype_rec {
+ templateAnytype_myAnytype x1,
+ templateAnytype_myAnytype x2,
+ templateAnytype_myAnytype x3 optional };
+template templateAnytype_rec templateAnytype_tSpec :={ //specific values
+ x1:={float:=1.2},
+ x2:={integer:=2},
+ x3:={integer:=3} };
+template templateAnytype_rec templateAnytype_tList :={ //specific value and value list
+ x1:={float:=1.2},
+ x2:=({integer:=2},{integer:=3},{float:=1.2}),
+ x3:={integer:=3} };
+template templateAnytype_rec templateAnytype_tComp :={ //specific value and compl. list
+ x1:={float:=1.2},
+ x2:=complement ({integer:=2},{float:=1.2},{integer:=6}),
+ x3:={integer:=3} };
+template templateAnytype_rec templateAnytype_tOmit :={ //omitting values
+ x1:={float:=1.2},
+ x2:={integer:=2},
+ x3:=omit } ;
+template templateAnytype_rec templateAnytype_tAny :={ //specific and any value
+ x1:={float:=1.2},
+ x2:={integer:=2},
+ x3:=? } ;
+template templateAnytype_rec templateAnytype_tAnyorNone :={ //specific and AnyorNone value
+ x1:={float:=1.2},
+ x2:={integer:=2},
+ x3:=* };
+template templateAnytype_rec templateAnytype_tIfpresent :={ //specific value and ifpresent
+ x1:={float:=1.2},
+ x2:={integer:=2},
+ x3:={integer:=3} ifpresent };
+
+testcase templateAnytypeSpec() runs on templateAnytype_mycomp {
+var templateAnytype_myAnytype temp:={integer:=3};
+var templateAnytype_rec x1,x2; //specific value
+x1:={ x1:={float:=1.2}, x2:={integer:=2}, x3:=temp };
+x2:={ x1:={float:=1.3}, x2:={integer:=2}, x3:=temp };
+//match
+if (match(x1,templateAnytype_tSpec)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match
+if (not(match(x2,templateAnytype_tSpec))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateAnytypeList() runs on templateAnytype_mycomp {
+var templateAnytype_myAnytype temp:={integer:=3};
+var templateAnytype_rec x1,x2,x3; //value list
+x1:={ x1:={float:=1.2}, x2:={integer:=3}, x3:=temp };
+x2:={ x1:={float:=1.2}, x2:={integer:=7}, x3:=temp };
+x3:={ x1:={integer:=8}, x2:={integer:=3}, x3:=temp };
+//match
+if (match(x1,templateAnytype_tList)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of list
+if (not(match(x2,templateAnytype_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateAnytype_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateAnytypeComp() runs on templateAnytype_mycomp {
+var templateAnytype_myAnytype temp:={integer:=3};
+var templateAnytype_rec x1,x2,x3; //complemented list
+x1:={ x1:={float:=1.2}, x2:={integer:=7}, x3:=temp };
+x2:={ x1:={float:=1.2}, x2:={integer:=6}, x3:=temp };
+x3:={ x1:={float:=1.3}, x2:={integer:=7}, x3:=temp };
+//match
+if (match(x1,templateAnytype_tComp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: in the list
+if (not(match(x2,templateAnytype_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateAnytype_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateAnytypeOmit() runs on templateAnytype_mycomp {
+var templateAnytype_myAnytype temp:={integer:=3};
+var templateAnytype_rec x1,x2,x3; //omitting value
+x1:={ x1:={float:=1.2}, x2:={integer:=2}, x3:=omit };
+x2:={ x1:={float:=1.2}, x2:={integer:=2}, x3:=temp };
+x3:={ x1:={integer:=2}, x2:={integer:=2}, x3:=omit };
+//match
+if (match(x1,templateAnytype_tOmit)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: not omitted
+if (not(match(x2,templateAnytype_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateAnytype_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateAnytypeAny() runs on templateAnytype_mycomp {
+var templateAnytype_myAnytype temp:={integer:=3};
+var templateAnytype_rec x1,x2,x3; //any value
+x1:={ x1:={float:=1.2}, x2:={integer:=2}, x3:=temp };
+x2:={ x1:={float:=1.2}, x2:={integer:=2}, x3:=omit };
+x3:={ x1:={integer:=2}, x2:={integer:=2}, x3:=temp };
+//match
+if (match(x1,templateAnytype_tAny)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: field omitted
+if (not(match(x2,templateAnytype_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateAnytype_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateAnytypeAnyorNone() runs on templateAnytype_mycomp {
+var templateAnytype_myAnytype temp:={integer:=3};
+var templateAnytype_rec x1,x2,x3; //AnyorNone value
+x1:={ x1:={float:=1.2}, x2:={integer:=2}, x3:=omit };
+x2:={ x1:={float:=1.2}, x2:={integer:=2}, x3:=temp };
+x3:={ x1:={integer:=2}, x2:={integer:=2}, x3:=omit };
+//match: omitted
+if (match(x1,templateAnytype_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: value
+if (match(x2,templateAnytype_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateAnytype_tAnyorNone))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateAnytypeIfpresent() runs on templateAnytype_mycomp {
+var templateAnytype_myAnytype temp1:={integer:=3}; //ifpresent
+var templateAnytype_myAnytype temp2:={integer:=4};
+var templateAnytype_rec x1,x2,x3,x4;
+x1:={ x1:={float:=1.2}, x2:={integer:=2}, x3:=temp1 };
+x2:={ x1:={float:=1.2}, x2:={integer:=2}, x3:=omit };
+x3:={ x1:={float:=1.2}, x2:={integer:=2}, x3:=temp2 };
+x4:={ x1:={float:=1.4}, x2:={integer:=2}, x3:=omit };
+//match: present and match
+if (match(x1,templateAnytype_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: not present
+if (match(x2,templateAnytype_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: present and not match
+if (not(match(x3,templateAnytype_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x4,templateAnytype_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+control {
+ execute(templateAnytypeSpec());
+ execute(templateAnytypeList());
+ execute(templateAnytypeComp());
+ execute(templateAnytypeOmit());
+ execute(templateAnytypeAny());
+ execute(templateAnytypeAnyorNone());
+ execute(templateAnytypeIfpresent());
+
+}
+}
+with {
+ extension "anytype integer, float"
+}
diff --git a/Regression_Test_java/src/TtemplateBitstr.ttcn b/Regression_Test_java/src/TtemplateBitstr.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..67004ec5982e0b7f3b6012abdac5dab04a6c0af7
--- /dev/null
+++ b/Regression_Test_java/src/TtemplateBitstr.ttcn
@@ -0,0 +1,476 @@
+/******************************************************************************
+ * 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:
+ * Baranyi, Botond
+ * Balasko, Jeno
+ * Kovacs, Ferenc
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TtemplateBitstr {
+type component templateBitstr_mycomp {};
+type record templateBitstr_rec {
+ bitstring x1,
+ bitstring x2,
+ bitstring x3 optional
+}
+with {
+ encode "JSON";
+ variant(x1) "JSON: name as first";
+ variant(x2) "JSON: name as second";
+ variant(x3) "JSON: name as third";
+}
+
+type record decmatch_rec {
+ integer i,
+ charstring s
+}
+with {
+ encode "JSON";
+}
+
+type record of integer decmatch_list
+with {
+ encode "XML";
+ variant "list";
+}
+
+//type union decmatch_uni {
+// integer i,
+// charstring s
+//}
+//with {
+// encode "RAW";
+// variant(i) "FIELDLENGTH(16)";
+//}
+
+
+template templateBitstr_rec templateBitstr_tSpec :={ //specific values
+ x1:='001'B,
+ x2:='010'B,
+ x3:='100'B };
+template templateBitstr_rec templateBitstr_tList :={ //specific value and value list
+ x1:='001'B,
+ x2:=('010'B,'011'B,'1100'B),
+ x3:='100'B };
+template templateBitstr_rec templateBitstr_tComp :={ //specific value and compl. list
+ x1:='001'B,
+ x2:=complement ('11'B,'00'B,'1000'B),
+ x3:='100'B };
+template templateBitstr_rec templateBitstr_tOmit :={ //omitting values
+ x1:='001'B,
+ x2:='010'B,
+ x3:=omit } ;
+template templateBitstr_rec templateBitstr_tAny :={ //specific and any value
+ x1:='001'B,
+ x2:='010'B,
+ x3:=? } ;
+template templateBitstr_rec templateBitstr_tAnyorNone :={ //specific and AnyorNone value
+ x1:='001'B,
+ x2:='010'B,
+ x3:=* };
+template templateBitstr_rec templateBitstr_tLength1 :={ //specific value and fix length
+ x1:='001'B,
+ x2:='010'B,
+ x3:=* length(3) };
+template templateBitstr_rec templateBitstr_tLength2 :={ //specific value and length (range)
+ x1:='001'B,
+ x2:='010'B,
+ x3:=? length(2..4) };
+template templateBitstr_rec templateBitstr_tLength3 :={ //specific value and length (range, infinity)
+ x1:='001'B,
+ x2:='010'B,
+ x3:=? length(2..infinity) };
+template templateBitstr_rec templateBitstr_tIfpresent :={ //specific value and ifpresent
+ x1:='001'B,
+ x2:='010'B,
+ x3:='100'B ifpresent };
+template templateBitstr_rec templateBitstr_tLengthIfp :={ //specific value and fix length and ifpresent
+ x1:='001'B,
+ x2:='010'B,
+ x3:= ? length(3) ifpresent};
+template templateBitstr_rec templateBitstr_tAnyEl :={ //specific value and any element inside value
+ x1:='001'B,
+ x2:='010'B,
+ x3:='10?'B } ;
+template templateBitstr_rec templateBitstr_tAnyorNoneEl :={ //specific value and Any number of elements or none inside value
+ x1:='001'B,
+ x2:='010'B,
+ x3:='10*'B };
+
+ template bitstring t_param1(templateBitstr_rec par) := substr(par.x1, 0, 1); // parameterised template
+
+//template decmatch_uni decmatch_tUnion := { i := ? };
+
+template decmatch_rec decmatch_tRecord := { i := (0..infinity), s := ? };
+
+//template templateBitstr_rec templateBitstr_tDecmatch := { // decoded content match
+// x1 := decmatch decmatch_list: { (1..10), (11..20), (21..30) },
+// x2 := decmatch decmatch_tUnion,
+// x3 := decmatch modifies decmatch_tRecord := { s := "abc" }
+//};
+//
+//template templateBitstr_rec templateBitstr_tDecmatchSelfRef := { // decoded content match with self-reference
+// x1 := '1011'B,
+// x2 := decmatch templateBitstr_tDecmatchSelfRef.x1,
+// x3 := decmatch templateBitstr_rec: { x1 := templateBitstr_tDecmatchSelfRef.x1, x2 := ?, x3 := * }
+//};
+
+testcase templateBitstrSpec() runs on templateBitstr_mycomp {
+var templateBitstr_rec x1,x2; //specific value
+x1:={ x1:='001'B, x2:='010'B, x3:='100'B };
+x2:={ x1:='00'B, x2:='010'B, x3:='100'B };
+//match
+if (match(x1,templateBitstr_tSpec)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match
+if (not(match(x2,templateBitstr_tSpec))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBitstrList() runs on templateBitstr_mycomp {
+var templateBitstr_rec x1,x2,x3; //value list
+x1:={ x1:='001'B, x2:='010'B, x3:='100'B };
+x2:={ x1:='001'B, x2:='00'B, x3:='100'B };
+x3:={ x1:='1'B, x2:='010'B, x3:='100'B };
+//match
+if (match(x1,templateBitstr_tList)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of list
+if (not(match(x2,templateBitstr_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateBitstr_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBitstrComp() runs on templateBitstr_mycomp {
+var templateBitstr_rec x1,x2,x3; //complemented list
+x1:={ x1:='001'B, x2:='010'B, x3:='100'B };
+x2:={ x1:='001'B, x2:='11'B, x3:='100'B };
+x3:={ x1:='11'B, x2:='010'B, x3:='100'B };
+//match
+if (match(x1,templateBitstr_tComp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: in the list
+if (not(match(x2,templateBitstr_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateBitstr_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBitstrOmit() runs on templateBitstr_mycomp {
+var templateBitstr_rec x1,x2,x3; //omitting value
+x1:={ x1:='001'B, x2:='010'B, x3:=omit };
+x2:={ x1:='001'B, x2:='010'B, x3:='000'B };
+x3:={ x1:='00'B, x2:='010'B, x3:=omit };
+//match
+if (match(x1,templateBitstr_tOmit)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: not omitted
+if (not(match(x2,templateBitstr_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateBitstr_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBitstrAny() runs on templateBitstr_mycomp {
+var templateBitstr_rec x1,x2,x3; //any value
+x1:={ x1:='001'B, x2:='010'B, x3:='111'B };
+x2:={ x1:='001'B, x2:='010'B, x3:=omit };
+x3:={ x1:='0'B, x2:='010'B, x3:='10'B };
+//match
+if (match(x1,templateBitstr_tAny)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: field omitted
+if (not(match(x2,templateBitstr_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateBitstr_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBitstrAnyorNone() runs on templateBitstr_mycomp {
+var templateBitstr_rec x1,x2,x3; //AnyorNone value
+x1:={ x1:='001'B, x2:='010'B, x3:=omit };
+x2:={ x1:='001'B, x2:='010'B, x3:='100'B };
+x3:={ x1:='1'B, x2:='010'B, x3:=omit };
+//match: omitted
+if (match(x1,templateBitstr_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: value
+if (match(x2,templateBitstr_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateBitstr_tAnyorNone))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBitstrLength1() runs on templateBitstr_mycomp {
+var templateBitstr_rec x1,x2,x3,x4; //length (fix)
+x1:={ x1:='001'B, x2:='010'B, x3:='111'B };
+x2:={ x1:='001'B, x2:='010'B, x3:=omit };
+x3:={ x1:='001'B, x2:='010'B, x3:='10'B };
+x4:={ x1:='0010'B, x2:='010'B, x3:='111'B };
+//match: proper length
+if (match(x1,templateBitstr_tLength1)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: omitted
+if (match(x2,templateBitstr_tLength1)) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: not proper length
+if (not(match(x3,templateBitstr_tLength1))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x4,templateBitstr_tLength1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBitstrLength2() runs on templateBitstr_mycomp {
+var templateBitstr_rec x1,x2,x3; //length (range)
+x1:={ x1:='001'B, x2:='010'B, x3:='111'B };
+x2:={ x1:='001'B, x2:='010'B, x3:='1'B };
+x3:={ x1:='0010'B, x2:='010'B, x3:='111'B };
+//match
+if (match(x1,templateBitstr_tLength2)) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: not proper length
+if (not(match(x2,templateBitstr_tLength2))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateBitstr_tLength2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBitstrLength3() runs on templateBitstr_mycomp {
+var templateBitstr_rec x1,x2,x3; //length (range, infinity)
+x1:={ x1:='001'B, x2:='010'B, x3:='111'B };
+x2:={ x1:='001'B, x2:='010'B, x3:='1'B };
+x3:={ x1:='0010'B, x2:='010'B, x3:='111'B };
+//match
+if (match(x1,templateBitstr_tLength3)) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: not proper length
+if (not(match(x2,templateBitstr_tLength3))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateBitstr_tLength3))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBitstrIfpresent() runs on templateBitstr_mycomp {
+var templateBitstr_rec x1,x2,x3,x4; //ifpresent
+x1:={ x1:='001'B, x2:='010'B, x3:='100'B };
+x2:={ x1:='001'B, x2:='010'B, x3:=omit };
+x3:={ x1:='001'B, x2:='010'B, x3:='000'B };
+x4:={ x1:='00'B, x2:='010'B, x3:=omit };
+//match: present and match
+if (match(x1,templateBitstr_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: not present
+if (match(x2,templateBitstr_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: present and not match
+if (not(match(x3,templateBitstr_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x4,templateBitstr_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBitstrLengthIfp() runs on templateBitstr_mycomp {
+var templateBitstr_rec x1,x2,x3,x4; //length (fix), ifpresent
+x1:={ x1:='001'B, x2:='010'B, x3:='111'B };
+x2:={ x1:='001'B, x2:='010'B, x3:=omit };
+x3:={ x1:='001'B, x2:='010'B, x3:='10'B };
+x4:={ x1:='0010'B, x2:='010'B, x3:='111'B };
+//match: proper length
+if (match(x1,templateBitstr_tLengthIfp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: omitted
+if (match(x2,templateBitstr_tLengthIfp)) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: not proper length
+if (not(match(x3,templateBitstr_tLengthIfp))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x4,templateBitstr_tLengthIfp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBitstrAnyEl() runs on templateBitstr_mycomp {
+var templateBitstr_rec x1,x2,x3,x4,x5; //any element
+x1:={ x1:='001'B, x2:='010'B, x3:='101'B };
+x2:={ x1:='001'B, x2:='010'B, x3:='10'B };
+x3:={ x1:='001'B, x2:='010'B, x3:='1000'B };
+x4:={ x1:='001'B, x2:='010'B, x3:='001'B };
+x5:={ x1:='0'B, x2:='010'B, x3:='101'B };
+//match
+if (match(x1,templateBitstr_tAnyEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: no element
+if (not(match(x2,templateBitstr_tAnyEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: two element
+if (not(match(x3,templateBitstr_tAnyEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: wrong element
+if (not(match(x4,templateBitstr_tAnyEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x5,templateBitstr_tAnyEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBitstrAnyorNoneEl() runs on templateBitstr_mycomp {
+var templateBitstr_rec x1,x2,x3,x4,x5; //Any number of elements or none
+x1:={ x1:='001'B, x2:='010'B, x3:='10'B };
+x2:={ x1:='001'B, x2:='010'B, x3:='100'B };
+x3:={ x1:='001'B, x2:='010'B, x3:='1011'B };
+x4:={ x1:='001'B, x2:='010'B, x3:='110'B };
+x5:={ x1:='1'B, x2:='010'B, x3:='100'B };
+//match: no element
+if (match(x1,templateBitstr_tAnyorNoneEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: one element
+if (match(x2,templateBitstr_tAnyorNoneEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: two element
+if (match(x3,templateBitstr_tAnyorNoneEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other element
+if (not(match(x4,templateBitstr_tAnyorNoneEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x5,templateBitstr_tAnyorNoneEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase CR_TR00018474() runs on templateBitstr_mycomp {
+ // Indexing of string template variables.
+ var template bitstring vtb1 := '0011110000'B
+ var template bitstring vtb2 := '0*?1'B // It's a pattern, cannot be indexed, runtime error.
+ vtb1[0] := '1'B
+ if (match('1011110000'B, vtb1)) { setverdict(pass) } else { setverdict(fail) }
+ vtb1[0] := '1'B // Indexed assignment notation cannot be used here.
+ vtb1[1] := '0'B // Still works, nothing special.
+ if (match('1011110000'B, vtb1)) { setverdict(pass) } else { setverdict(fail) }
+}
+
+//testcase templateBitstrDecmatch() runs on templateBitstr_mycomp {
+// var decmatch_rec bad_rec, good_rec;
+// bad_rec := { i := 11, s := "xyz" };
+// good_rec := { i := 3, s := "abc" };
+// var decmatch_list bad_list, good_list;
+// bad_list := { 4, 7, 10 };
+// good_list := { 2, 15, 28 };
+// var decmatch_uni bad_uni, good_uni;
+// bad_uni := { s := "five" };
+// good_uni := { i := 5 };
+// var bitstring bad_rec_enc, good_rec_enc, bad_list_enc, good_list_enc, bad_uni_enc, good_uni_enc;
+// bad_rec_enc := encvalue(bad_rec);
+// good_rec_enc := encvalue(good_rec);
+// bad_list_enc := encvalue(bad_list);
+// good_list_enc := encvalue(good_list);
+// bad_uni_enc := encvalue(bad_uni);
+// good_uni_enc := encvalue(good_uni);
+// var templateBitstr_rec r1, r2, r3, r4, r5;
+// r1 := { x1 := good_list_enc, x2 := good_uni_enc, x3 := good_rec_enc };
+// r2 := { x1 := bad_list_enc, x2 := good_uni_enc, x3 := good_rec_enc };
+// r3 := { x1 := good_list_enc, x2 := bad_uni_enc, x3 := good_rec_enc };
+// r4 := { x1 := good_list_enc, x2 := good_uni_enc, x3 := bad_rec_enc };
+// r5 := { x1 := good_list_enc, x2 := good_uni_enc, x3 := '11110011'B };
+// // match: all 3 are good
+// if (match(r1, templateBitstr_tDecmatch)) { setverdict(pass); }
+// else { setverdict(fail, 1); }
+// // no match: decoded list does not match
+// if (not match(r2, templateBitstr_tDecmatch)) { setverdict(pass); }
+// else { setverdict(fail, 2); }
+// // no match: decoded union does not match
+// if (not match(r3, templateBitstr_tDecmatch)) { setverdict(pass); }
+// else { setverdict(fail, 3); }
+// // no match: decoded record does not match
+// if (not match(r4, templateBitstr_tDecmatch)) { setverdict(pass); }
+// else { setverdict(fail, 4); }
+// // no match: x3 is not a valid encoded record value
+// if (not match(r5, templateBitstr_tDecmatch)) { setverdict(pass); }
+// else { setverdict(fail, 5); }
+// // match r1 with the same template declared as an in-line template
+// if (match(r1, templateBitstr_rec: {
+// x1 := decmatch decmatch_list: { (1..10), (11..20), (21..30) },
+// x2 := decmatch decmatch_tUnion,
+// x3 := decmatch modifies decmatch_tRecord := { s := "abc" }
+// })) { setverdict(pass); }
+// else { setverdict(fail, 6); }
+//}
+
+//external function ef_enc_rec_x1(in templateBitstr_rec.x1 x) return octetstring
+//with { extension "prototype(convert) encode(JSON)" }
+//
+//testcase templateBitstrDecmatchSelfRef() runs on templateBitstr_mycomp {
+// // global self-referencing template
+// var templateBitstr_rec.x1 bad_bs, good_bs;
+// bad_bs := '11'B;
+// good_bs := '1011'B;
+// var templateBitstr_rec bad_rec, good_rec;
+// bad_rec := { x1 := '01'B, x2 := '10'B, x3 := '11'B };
+// good_rec := { x1 := '1011'B, x2 := '10'B, x3 := '11'B };
+// var bitstring bad_bs_enc, good_bs_enc, bad_rec_enc, good_rec_enc;
+// bad_bs_enc := oct2bit(ef_enc_rec_x1(bad_bs));
+// good_bs_enc := oct2bit(ef_enc_rec_x1(good_bs));
+// bad_rec_enc := encvalue(bad_rec);
+// good_rec_enc := encvalue(good_rec);
+// var templateBitstr_rec r1, r2, r3;
+// r1 := { x1 := '1011'B, x2 := good_bs_enc, x3 := good_rec_enc };
+// r2 := { x1 := '1011'B, x2 := bad_bs_enc, x3 := good_rec_enc };
+// r3 := { x1 := '1011'B, x2 := good_bs_enc, x3 := bad_rec_enc };
+// // match: all 2 are good
+// if (match(r1, templateBitstr_tDecmatchSelfRef)) { setverdict(pass); }
+// else { setverdict(fail, 1); }
+// // no match: decoded octetstring does not match
+// if (not match(r2, templateBitstr_tDecmatchSelfRef)) { setverdict(pass); }
+// else { setverdict(fail, 2); }
+// // no match: decoded record does not match
+// if (not match(r3, templateBitstr_tDecmatchSelfRef)) { setverdict(pass); }
+// else { setverdict(fail, 3); }
+//
+// // local self-referencing template
+// var template templateBitstr_rec t := { x1 := '1011'B, x2 := ?, x3 := ? };
+// t.x1 := decmatch t;
+// var templateBitstr_rec r4, r5;
+// r4 := { x1 := good_rec_enc, x2 := '10'B, x3 := '11'B };
+// r5 := { x1 := bad_rec_enc, x2 := '10'B, x3 := '11'B };
+// if (match(r4, t)) { setverdict(pass); }
+// else { setverdict(fail, 4); }
+// if (not match(r5, t)) { setverdict(pass); }
+// else { setverdict(fail, 5); }
+//}
+
+control {
+ execute(templateBitstrSpec());
+ execute(templateBitstrList());
+ execute(templateBitstrComp());
+ execute(templateBitstrOmit());
+ execute(templateBitstrAny());
+ execute(templateBitstrAnyorNone());
+ execute(templateBitstrLength1());
+ execute(templateBitstrLength2());
+ execute(templateBitstrLength3());
+ execute(templateBitstrIfpresent());
+ execute(templateBitstrLengthIfp());
+ execute(templateBitstrAnyEl());
+ execute(templateBitstrAnyorNoneEl());
+ execute(CR_TR00018474());
+// execute(templateBitstrDecmatch());
+// execute(templateBitstrDecmatchSelfRef());
+}
+}
diff --git a/Regression_Test_java/src/TtemplateBool.ttcn b/Regression_Test_java/src/TtemplateBool.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..8a2add8b9ee749175f7c297a0bce2cfcfa6e4baa
--- /dev/null
+++ b/Regression_Test_java/src/TtemplateBool.ttcn
@@ -0,0 +1,172 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TtemplateBool {
+type component templateBool_mycomp {};
+type record templateBool_rec {
+ boolean x1,
+ boolean x2,
+ boolean x3 optional };
+template templateBool_rec templateBool_tSpec :={ //specific values
+ x1:=true,
+ x2:=false,
+ x3:=false };
+template templateBool_rec templateBool_tList :={ //specific value and value list
+ x1:=true,
+ x2:=(false),
+ x3:=false };
+template templateBool_rec templateBool_tComp :={ //specific value and compl. list
+ x1:=true,
+ x2:=complement (true),
+ x3:=false };
+template templateBool_rec templateBool_tOmit :={ //omitting values
+ x1:=true,
+ x2:=false,
+ x3:=omit } ;
+template templateBool_rec templateBool_tAny :={ //specific and any value
+ x1:=true,
+ x2:=false,
+ x3:=? } ;
+template templateBool_rec templateBool_tAnyorNone :={ //specific and AnyorNone value
+ x1:=true,
+ x2:=false,
+ x3:=* };
+template templateBool_rec templateBool_tIfpresent :={ //specific value and ifpresent
+ x1:=true,
+ x2:=false,
+ x3:=false ifpresent };
+
+testcase templateBoolSpec() runs on templateBool_mycomp {
+var templateBool_rec x1,x2; //specific value
+x1:={ x1:=true, x2:=false, x3:=false };
+x2:={ x1:=true, x2:=true, x3:=false };
+//match
+if (match(x1,templateBool_tSpec)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match
+if (not(match(x2,templateBool_tSpec))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBoolList() runs on templateBool_mycomp {
+var templateBool_rec x1,x2,x3; //value list
+x1:={ x1:=true, x2:=false, x3:=false };
+x2:={ x1:=true, x2:=true, x3:=false };
+x3:={ x1:=false, x2:=false, x3:=false };
+//match
+if (match(x1,templateBool_tList)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of list
+if (not(match(x2,templateBool_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateBool_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBoolComp() runs on templateBool_mycomp {
+var templateBool_rec x1,x2,x3; //complemented list
+x1:={ x1:=true, x2:=false, x3:=false };
+x2:={ x1:=true, x2:=true, x3:=false };
+x3:={ x1:=false, x2:=false, x3:=false };
+//match
+if (match(x1,templateBool_tComp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: in the list
+if (not(match(x2,templateBool_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateBool_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBoolOmit() runs on templateBool_mycomp {
+var templateBool_rec x1,x2,x3; //omitting value
+x1:={ x1:=true, x2:=false, x3:=omit };
+x2:={ x1:=true, x2:=false, x3:=true };
+x3:={ x1:=false, x2:=false, x3:=omit };
+//match
+if (match(x1,templateBool_tOmit)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: not omitted
+if (not(match(x2,templateBool_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateBool_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBoolAny() runs on templateBool_mycomp {
+var templateBool_rec x1,x2,x3; //any value
+x1:={ x1:=true, x2:=false, x3:=false };
+x2:={ x1:=true, x2:=false, x3:=omit };
+x3:={ x1:=false, x2:=false, x3:=false };
+//match
+if (match(x1,templateBool_tAny)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: field omitted
+if (not(match(x2,templateBool_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateBool_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBoolAnyorNone() runs on templateBool_mycomp {
+var templateBool_rec x1,x2,x3; //AnyorNone value
+x1:={ x1:=true, x2:=false, x3:=omit };
+x2:={ x1:=true, x2:=false, x3:=true };
+x3:={ x1:=false, x2:=false, x3:=omit };
+//match: omitted
+if (match(x1,templateBool_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: value
+if (match(x2,templateBool_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateBool_tAnyorNone))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateBoolIfpresent() runs on templateBool_mycomp {
+var templateBool_rec x1,x2,x3,x4; //ifpresent
+x1:={ x1:=true, x2:=false, x3:=false };
+x2:={ x1:=true, x2:=false, x3:=omit };
+x3:={ x1:=true, x2:=false, x3:=true };
+x4:={ x1:=false, x2:=false, x3:=omit };
+//match: present and match
+if (match(x1,templateBool_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: not present
+if (match(x2,templateBool_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: present and not match
+if (not(match(x3,templateBool_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x4,templateBool_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+control {
+ execute(templateBoolSpec());
+ execute(templateBoolList());
+ execute(templateBoolComp());
+ execute(templateBoolOmit());
+ execute(templateBoolAny());
+ execute(templateBoolAnyorNone());
+ execute(templateBoolIfpresent());
+
+}
+}
diff --git a/Regression_Test_java/src/TtemplateChar.ttcn b/Regression_Test_java/src/TtemplateChar.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..3c636467f509f75d0505516dfa349d8f9231d7cb
--- /dev/null
+++ b/Regression_Test_java/src/TtemplateChar.ttcn
@@ -0,0 +1,255 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TtemplateChar {
+type component templateChar_mycomp {};
+type record templateChar_rec {
+ char x1,
+ char x2,
+ char x3 optional };
+template templateChar_rec templateChar_tSpec :={ //specific values
+ x1:="a",
+ x2:="b",
+ x3:="c" };
+template templateChar_rec templateChar_tList :={ //specific value and value list
+ x1:="a",
+ x2:=("a","b","k"),
+ x3:="c" };
+template templateChar_rec templateChar_tComp :={ //specific value and compl. list
+ x1:="a",
+ x2:=complement ("b","2","l"),
+ x3:="c" };
+template templateChar_rec templateChar_tOmit :={ //omitting values
+ x1:="a",
+ x2:="b",
+ x3:=omit } ;
+template templateChar_rec templateChar_tAny :={ //specific and any value
+ x1:="a",
+ x2:="b",
+ x3:=? } ;
+template templateChar_rec templateChar_tAnyorNone :={ //specific and AnyorNone value
+ x1:="a",
+ x2:="b",
+ x3:=* };
+template templateChar_rec templateChar_tRange1 :={ //specific value and Range
+ x1:="a",
+ x2:=("a" .."h"),
+ x3:="c" };
+template templateChar_rec templateChar_tRange2 :={ //specific value and Range
+ x1:="a",
+ x2:=("a" .. "h"),
+ x3:="c" };
+template templateChar_rec templateChar_tRange3 :={ //specific value and Range
+ x1:="a",
+ x2:=("k" .. int2char(127)),
+ x3:="c" };
+template templateChar_rec templateChar_tRange4 :={ //specific value and Range
+ x1:="a",
+ x2:=(int2char(0) .. "k"),
+ x3:="c" };
+template templateChar_rec templateChar_tIfpresent :={ //specific value and ifpresent
+ x1:="a",
+ x2:="b",
+ x3:="c" ifpresent };
+
+testcase templateCharSpec() runs on templateChar_mycomp {
+var templateChar_rec x1,x2; //specific value
+x1:={ x1:="a", x2:="b", x3:="c" };
+x2:={ x1:="k", x2:="b", x3:="c" };
+//match
+if (match(x1,templateChar_tSpec)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match
+if (not(match(x2,templateChar_tSpec))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateCharList() runs on templateChar_mycomp {
+var templateChar_rec x1,x2,x3; //value list
+x1:={ x1:="a", x2:="b", x3:="c" };
+x2:={ x1:="a", x2:="h", x3:="c" };
+x3:={ x1:="k", x2:="b", x3:="c" };
+//match
+if (match(x1,templateChar_tList)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of list
+if (not(match(x2,templateChar_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateChar_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateCharComp() runs on templateChar_mycomp {
+var templateChar_rec x1,x2,x3; //complemented list
+x1:={ x1:="a", x2:="c", x3:="c" };
+x2:={ x1:="a", x2:="2", x3:="c" };
+x3:={ x1:="k", x2:="c", x3:="c" };
+//match
+if (match(x1,templateChar_tComp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: in the list
+if (not(match(x2,templateChar_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateChar_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateCharOmit() runs on templateChar_mycomp {
+var templateChar_rec x1,x2,x3; //omitting value
+x1:={ x1:="a", x2:="b", x3:=omit };
+x2:={ x1:="a", x2:="b", x3:="o" };
+x3:={ x1:="l", x2:="b", x3:=omit };
+//match
+if (match(x1,templateChar_tOmit)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: not omitted
+if (not(match(x2,templateChar_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateChar_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateCharAny() runs on templateChar_mycomp {
+var templateChar_rec x1,x2,x3; //any value
+x1:={ x1:="a", x2:="b", x3:="l" };
+x2:={ x1:="a", x2:="b", x3:=omit };
+x3:={ x1:="k", x2:="b", x3:="l" };
+//match
+if (match(x1,templateChar_tAny)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: field omitted
+if (not(match(x2,templateChar_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateChar_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateCharAnyorNone() runs on templateChar_mycomp {
+var templateChar_rec x1,x2,x3; //AnyorNone value
+x1:={ x1:="a", x2:="b", x3:=omit };
+x2:={ x1:="a", x2:="b", x3:="m" };
+x3:={ x1:="p", x2:="b", x3:=omit };
+//match: omitted
+if (match(x1,templateChar_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: value
+if (match(x2,templateChar_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateChar_tAnyorNone))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateCharRange1() runs on templateChar_mycomp {
+var templateChar_rec x1,x2,x3; //Range ( .. )
+x1:={ x1:="a", x2:="d", x3:="c" };
+x2:={ x1:="a", x2:="p", x3:="c" };
+x3:={ x1:="l", x2:="d", x3:="c" };
+//match
+if (match(x1,templateChar_tRange1)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of range
+if (not(match(x2,templateChar_tRange1))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateChar_tRange1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateCharRange2() runs on templateChar_mycomp {
+var templateChar_rec x1,x2,x3; //Range ( to )
+x1:={ x1:="a", x2:="d", x3:="c" };
+x2:={ x1:="a", x2:="p", x3:="c" };
+x3:={ x1:="l", x2:="d", x3:="c" };
+//match
+if (match(x1,templateChar_tRange2)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of range
+if (not(match(x2,templateChar_tRange2))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateChar_tRange2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateCharRange3() runs on templateChar_mycomp {
+var templateChar_rec x1,x2,x3; //Range, with infinity
+x1:={ x1:="a", x2:="p", x3:="c" };
+x2:={ x1:="a", x2:="d", x3:="c" };
+x3:={ x1:="l", x2:="p", x3:="c" };
+//match
+if (match(x1,templateChar_tRange3)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of range
+if (not(match(x2,templateChar_tRange3))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateChar_tRange3))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateCharRange4() runs on templateChar_mycomp {
+var templateChar_rec x1,x2,x3; //Range with - infinity
+x1:={ x1:="a", x2:="d", x3:="c" };
+x2:={ x1:="a", x2:="p", x3:="c" };
+x3:={ x1:="l", x2:="d", x3:="c" };
+//match
+if (match(x1,templateChar_tRange4)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of range
+if (not(match(x2,templateChar_tRange4))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateChar_tRange4))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateCharIfpresent() runs on templateChar_mycomp {
+var templateChar_rec x1,x2,x3,x4; //ifpresent
+x1:={ x1:="a", x2:="b", x3:="c" };
+x2:={ x1:="a", x2:="b", x3:=omit };
+x3:={ x1:="a", x2:="b", x3:="k" };
+x4:={ x1:="c", x2:="b", x3:=omit };
+//match: present and match
+if (match(x1,templateChar_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: not present
+if (match(x2,templateChar_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: present and not match
+if (not(match(x3,templateChar_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x4,templateChar_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+control {
+ execute(templateCharSpec());
+ execute(templateCharList());
+ execute(templateCharComp());
+ execute(templateCharOmit());
+ execute(templateCharAny());
+ execute(templateCharAnyorNone());
+ execute(templateCharRange1());
+ execute(templateCharRange2());
+ execute(templateCharRange3());
+ execute(templateCharRange4());
+ execute(templateCharIfpresent());
+}
+}
diff --git a/Regression_Test_java/src/TtemplateEnum.ttcn b/Regression_Test_java/src/TtemplateEnum.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..95f61376ff68f64ebfeb4a0f17711d59a67d6110
--- /dev/null
+++ b/Regression_Test_java/src/TtemplateEnum.ttcn
@@ -0,0 +1,172 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TtemplateEnum {
+type component templateEnum_mycomp {};
+type enumerated templateEnum_myenum {xx1,xx2,xx3,xx4,xx5,xx6,xx7};
+type record templateEnum_rec {
+ templateEnum_myenum x1,
+ templateEnum_myenum x2,
+ templateEnum_myenum x3 optional };
+template templateEnum_rec templateEnum_tSpec :={ //specific values
+ x1:=xx1,
+ x2:=xx2,
+ x3:=xx3 };
+template templateEnum_rec templateEnum_tList :={ //specific value and value list
+ x1:=xx1,
+ x2:=(xx2,xx3,xx6),
+ x3:=xx3 };
+template templateEnum_rec templateEnum_tComp :={ //specific value and compl. list
+ x1:=xx1,
+ x2:=complement (xx2,xx3,xx6),
+ x3:=xx3 };
+template templateEnum_rec templateEnum_tOmit :={ //omitting values
+ x1:=xx1,
+ x2:=xx2,
+ x3:=omit } ;
+template templateEnum_rec templateEnum_tAny :={ //specific and any value
+ x1:=xx1,
+ x2:=xx2,
+ x3:=? } ;
+template templateEnum_rec templateEnum_tAnyorNone :={ //specific and AnyorNone value
+ x1:=xx1,
+ x2:=xx2,
+ x3:=* };
+template templateEnum_rec templateEnum_tIfpresent :={ //specific value and ifpresent
+ x1:=xx1,
+ x2:=xx2,
+ x3:=xx3 ifpresent };
+
+testcase templateEnumSpec() runs on templateEnum_mycomp {
+var templateEnum_rec x1,x2; //specific value
+x1:={ x1:=xx1, x2:=xx2, x3:=xx3 };
+x2:={ x1:=xx2, x2:=xx2, x3:=xx3 };
+//match
+if (match(x1,templateEnum_tSpec)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match
+if (not(match(x2,templateEnum_tSpec))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateEnumList() runs on templateEnum_mycomp {
+var templateEnum_rec x1,x2,x3; //value list
+x1:={ x1:=xx1, x2:=xx6, x3:=xx3 };
+x2:={ x1:=xx1, x2:=xx7, x3:=xx3 };
+x3:={ x1:=xx2, x2:=xx6, x3:=xx3 };
+//match
+if (match(x1,templateEnum_tList)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of list
+if (not(match(x2,templateEnum_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateEnum_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateEnumComp() runs on templateEnum_mycomp {
+var templateEnum_rec x1,x2,x3; //complemented list
+x1:={ x1:=xx1, x2:=xx7, x3:=xx3 };
+x2:={ x1:=xx1, x2:=xx6, x3:=xx3 };
+x3:={ x1:=xx2, x2:=xx7, x3:=xx3 };
+//match
+if (match(x1,templateEnum_tComp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: in the list
+if (not(match(x2,templateEnum_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateEnum_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateEnumOmit() runs on templateEnum_mycomp {
+var templateEnum_rec x1,x2,x3; //omitting value
+x1:={ x1:=xx1, x2:=xx2, x3:=omit };
+x2:={ x1:=xx1, x2:=xx2, x3:=xx3 };
+x3:={ x1:=xx2, x2:=xx2, x3:=omit };
+//match
+if (match(x1,templateEnum_tOmit)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: not omitted
+if (not(match(x2,templateEnum_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateEnum_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateEnumAny() runs on templateEnum_mycomp {
+var templateEnum_rec x1,x2,x3; //any value
+x1:={ x1:=xx1, x2:=xx2, x3:=xx3 };
+x2:={ x1:=xx2, x2:=xx2, x3:=xx3 };
+x3:={ x1:=xx1, x2:=xx2, x3:=omit };
+//match
+if (match(x1,templateEnum_tAny)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: field omitted
+if (not(match(x2,templateEnum_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateEnum_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateEnumAnyorNone() runs on templateEnum_mycomp {
+var templateEnum_rec x1,x2,x3; //AnyorNone value
+x1:={ x1:=xx1, x2:=xx2, x3:=omit };
+x2:={ x1:=xx1, x2:=xx2, x3:=xx3 };
+x3:={ x1:=xx2, x2:=xx2, x3:=omit };
+//match: omitted
+if (match(x1,templateEnum_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: value
+if (match(x2,templateEnum_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateEnum_tAnyorNone))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateEnumIfpresent() runs on templateEnum_mycomp {
+var templateEnum_rec x1,x2,x3,x4; //ifpresent
+x1:={ x1:=xx1, x2:=xx2, x3:=xx3 };
+x2:={ x1:=xx1, x2:=xx2, x3:=omit };
+x3:={ x1:=xx2, x2:=xx2, x3:=omit };
+x4:={ x1:=xx1, x2:=xx2, x3:=xx4 };
+//match: present and match
+if (match(x1,templateEnum_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: not present
+if (match(x2,templateEnum_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: present and not match
+if (not(match(x3,templateEnum_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x4,templateEnum_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+control {
+ execute(templateEnumSpec());
+ execute(templateEnumList());
+ execute(templateEnumComp());
+ execute(templateEnumOmit());
+ execute(templateEnumAny());
+ execute(templateEnumAnyorNone());
+ execute(templateEnumIfpresent());
+}
+}
diff --git a/Regression_Test_java/src/TtemplateFloat.ttcn b/Regression_Test_java/src/TtemplateFloat.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..21dc6f79d01e9f7afbdead54cc1036e134a8c408
--- /dev/null
+++ b/Regression_Test_java/src/TtemplateFloat.ttcn
@@ -0,0 +1,275 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TtemplateFloat {
+type component templateFloat_mycomp {};
+type record templateFloat_rec {
+ float x1,
+ float x2,
+ float x3 optional };
+template templateFloat_rec templateFloat_tSpec :={ //specific values
+ x1:=1.1,
+ x2:=2.1,
+ x3:=3.1 };
+template templateFloat_rec templateFloat_tList :={ //specific value and value list
+ x1:=1.1,
+ x2:=(2.1,3.1,6.1),
+ x3:=3.1 };
+template templateFloat_rec templateFloat_tComp :={ //specific value and compl. list
+ x1:=1.1,
+ x2:=complement (2.1,3.1,6.1),
+ x3:=3.1 };
+template templateFloat_rec templateFloat_tOmit :={ //omitting values
+ x1:=1.1,
+ x2:=2.1,
+ x3:=omit } ;
+template templateFloat_rec templateFloat_tAny :={ //specific and any value
+ x1:=1.1,
+ x2:=2.1,
+ x3:=? } ;
+template templateFloat_rec templateFloat_tAnyorNone :={ //specific and AnyorNone value
+ x1:=1.1,
+ x2:=2.1,
+ x3:=* };
+template templateFloat_rec templateFloat_tRange1 :={ //specific value and Range
+ x1:=1.1,
+ x2:=(2.1 ..4.1),
+ x3:=3.1 };
+template templateFloat_rec templateFloat_tRange2 :={ //specific value and Range
+ x1:=1.1,
+ x2:=(2.1 .. 4.1),
+ x3:=3.1 };
+template templateFloat_rec templateFloat_tRange3 :={ //specific value and Range
+ x1:=1.1,
+ x2:=(2.1 .. infinity),
+ x3:=3.1 };
+template templateFloat_rec templateFloat_tRange4 :={ //specific value and Range
+ x1:=1.1,
+ x2:=(-infinity .. 4.1),
+ x3:=3.1 };
+template templateFloat_rec templateFloat_tIfpresent :={ //specific value and ifpresent
+ x1:=1.1,
+ x2:=2.1,
+ x3:=3.1 ifpresent };
+
+template float templateFloat_tNaN := not_a_number;
+template float templateFloat_tPosInf := infinity;
+template float templateFloat_tNegInf := -infinity;
+
+testcase templateFloatSpec() runs on templateFloat_mycomp {
+var templateFloat_rec x1,x2; //specific value
+x1:={ x1:=1.1, x2:=2.1, x3:=3.1 };
+x2:={ x1:=2.1, x2:=2.1, x3:=3.1 };
+//match
+if (match(x1,templateFloat_tSpec)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match
+if (not(match(x2,templateFloat_tSpec))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateFloatList() runs on templateFloat_mycomp {
+var templateFloat_rec x1,x2,x3; //value list
+x1:={ x1:=1.1, x2:=6.1, x3:=3.1 };
+x2:={ x1:=1.1, x2:=7.1, x3:=3.1 };
+x3:={ x1:=2.1, x2:=6.1, x3:=3.1 };
+//match
+if (match(x1,templateFloat_tList)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of list
+if (not(match(x2,templateFloat_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateFloat_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateFloatComp() runs on templateFloat_mycomp {
+var templateFloat_rec x1,x2,x3; //complemented list
+x1:={ x1:=1.1, x2:=7.1, x3:=3.1 };
+x2:={ x1:=1.1, x2:=6.1, x3:=3.1 };
+x3:={ x1:=2.1, x2:=7.1, x3:=3.1 };
+//match
+if (match(x1,templateFloat_tComp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: in the list
+if (not(match(x2,templateFloat_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateFloat_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateFloatOmit() runs on templateFloat_mycomp {
+var templateFloat_rec x1,x2,x3; //omitting value
+x1:={ x1:=1.1, x2:=2.1, x3:=omit };
+x2:={ x1:=1.1, x2:=2.1, x3:=3.1 };
+x3:={ x1:=2.1, x2:=2.1, x3:=omit };
+//match
+if (match(x1,templateFloat_tOmit)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: not omitted
+if (not(match(x2,templateFloat_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateFloat_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateFloatAny() runs on templateFloat_mycomp {
+var templateFloat_rec x1,x2,x3; //any value
+x1:={ x1:=1.1, x2:=2.1, x3:=3.1 };
+x2:={ x1:=1.1, x2:=2.1, x3:=omit };
+x3:={ x1:=2.1, x2:=2.1, x3:=3.1 };
+//match
+if (match(x1,templateFloat_tAny)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: field omitted
+if (not(match(x2,templateFloat_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateFloat_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateFloatAnyorNone() runs on templateFloat_mycomp {
+var templateFloat_rec x1,x2,x3; //AnyorNone value
+x1:={ x1:=1.1, x2:=2.1, x3:=omit };
+x2:={ x1:=1.1, x2:=2.1, x3:=3.1 };
+x3:={ x1:=2.1, x2:=2.1, x3:=omit };
+//match: omitted
+if (match(x1,templateFloat_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: value
+if (match(x2,templateFloat_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateFloat_tAnyorNone))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateFloatRange1() runs on templateFloat_mycomp {
+var templateFloat_rec x1,x2,x3; //Range ( .. )
+x1:={ x1:=1.1, x2:=2.1, x3:=3.1 };
+x2:={ x1:=1.1, x2:=5.1, x3:=3.1 };
+x3:={ x1:=2.1, x2:=2.1, x3:=3.1 };
+//match
+if (match(x1,templateFloat_tRange1)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of range
+if (not(match(x2,templateFloat_tRange1))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateFloat_tRange1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateFloatRange2() runs on templateFloat_mycomp {
+var templateFloat_rec x1,x2,x3; //Range ( to )
+x1:={ x1:=1.1, x2:=2.1, x3:=3.1 };
+x2:={ x1:=1.1, x2:=5.1, x3:=3.1 };
+x3:={ x1:=2.1, x2:=2.1, x3:=3.1 };
+//match
+if (match(x1,templateFloat_tRange2)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of range
+if (not(match(x2,templateFloat_tRange2))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateFloat_tRange2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateFloatRange3() runs on templateFloat_mycomp {
+var templateFloat_rec x1,x2,x3; //Range, with infinity
+x1:={ x1:=1.1, x2:=8.1, x3:=3.1 };
+x2:={ x1:=1.1, x2:=-5.1, x3:=3.1 };
+x3:={ x1:=2.1, x2:=2.1, x3:=3.1 };
+//match
+if (match(x1,templateFloat_tRange3)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of range
+if (not(match(x2,templateFloat_tRange3))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateFloat_tRange3))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateFloatRange4() runs on templateFloat_mycomp {
+var templateFloat_rec x1,x2,x3; //Range with - infinity
+x1:={ x1:=1.1, x2:=-2.1, x3:=3.1 };
+x2:={ x1:=1.1, x2:=5.1, x3:=3.1 };
+x3:={ x1:=2.1, x2:=2.1, x3:=3.1 };
+//match
+if (match(x1,templateFloat_tRange4)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of range
+if (not(match(x2,templateFloat_tRange4))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateFloat_tRange4))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateFloatIfpresent() runs on templateFloat_mycomp {
+var templateFloat_rec x1,x2,x3,x4; //ifpresent
+x1:={ x1:=1.1, x2:=2.1, x3:=3.1 };
+x2:={ x1:=1.1, x2:=2.1, x3:=omit };
+x3:={ x1:=1.1, x2:=2.1, x3:=4.1 };
+x4:={ x1:=2.1, x2:=2.1, x3:=omit };
+//match: present and match
+if (match(x1,templateFloat_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: not present
+if (match(x2,templateFloat_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: present and not match
+if (not(match(x3,templateFloat_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+////no match: other field
+if (not(match(x4,templateFloat_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateFloatSpecialValues() runs on templateFloat_mycomp {
+ var float v_nan := not_a_number;
+ var float v_pos_inf := infinity;
+ var float v_neg_inf := -infinity;
+
+ if (match(v_nan, templateFloat_tNaN)) { setverdict(pass); }
+ else { setverdict(fail, "not_a_number should match itself"); }
+
+ if (match(v_pos_inf, templateFloat_tPosInf)) { setverdict(pass); }
+ else { setverdict(fail, "infinity should match itself"); }
+
+ if (match(v_neg_inf, templateFloat_tNegInf)) { setverdict(pass); }
+ else { setverdict(fail, "-infinity should match itself"); }
+}
+
+control {
+ execute(templateFloatSpec());
+ execute(templateFloatList());
+ execute(templateFloatComp());
+ execute(templateFloatOmit());
+ execute(templateFloatAny());
+ execute(templateFloatAnyorNone());
+ execute(templateFloatRange1());
+ execute(templateFloatRange2());
+ execute(templateFloatRange3());
+ execute(templateFloatRange4());
+ execute(templateFloatIfpresent());
+ execute(templateFloatSpecialValues());
+}
+}
diff --git a/Regression_Test_java/src/TtemplateInt.ttcn b/Regression_Test_java/src/TtemplateInt.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..de423b5f1a41aeb722e2e3f4b3a0558fb8b600d1
--- /dev/null
+++ b/Regression_Test_java/src/TtemplateInt.ttcn
@@ -0,0 +1,397 @@
+/******************************************************************************
+ * 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
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TtemplateInt {
+
+import from ImportedTemplates all;
+
+type component templateInt_mycomp {};
+type record templateInt_rec {
+ integer x1,
+ integer x2,
+ integer x3 optional };
+type integer templateInt_subtype (0..1457664);
+
+template templateInt_rec templateInt_tSpec :={ //specific values
+ x1:=1,
+ x2:=2,
+ x3:=3 };
+template templateInt_rec templateInt_tList :={ //specific value and value list
+ x1:=1,
+ x2:=(2,3,6),
+ x3:=3 };
+template templateInt_rec templateInt_tComp :={ //specific value and compl. list
+ x1:=1,
+ x2:=complement (2,3,6),
+ x3:=3 };
+template templateInt_rec templateInt_tOmit :={ //omitting values
+ x1:=1,
+ x2:=2,
+ x3:=omit } ;
+template templateInt_rec templateInt_tAny :={ //specific and any value
+ x1:=1,
+ x2:=2,
+ x3:=? } ;
+template templateInt_rec templateInt_tAnyorNone :={ //specific and AnyorNone value
+ x1:=1,
+ x2:=2,
+ x3:=* };
+template templateInt_rec templateInt_tRange1 :={ //specific value and Range
+ x1:=1,
+ x2:=(2 ..4),
+ x3:=3 };
+template templateInt_rec templateInt_tRange2 :={ //specific value and Range
+ x1:=1,
+ x2:=(2 .. 4),
+ x3:=3 };
+template templateInt_rec templateInt_tRange3 :={ //specific value and Range
+ x1:=1,
+ x2:=(2 .. infinity),
+ x3:=3 };
+template templateInt_rec templateInt_tRange4 :={ //specific value and Range
+ x1:=1,
+ x2:=(-infinity .. 4),
+ x3:=3 };
+template templateInt_rec templateInt_tIfpresent :={ //specific value and ifpresent
+ x1:=1,
+ x2:=2,
+ x3:=3 ifpresent };
+
+testcase templateIntSpec() runs on templateInt_mycomp {
+var templateInt_rec x1,x2; //specific value
+x1:={ x1:=1, x2:=2, x3:=3 };
+x2:={ x1:=2, x2:=2, x3:=3 };
+//match
+if (match(x1,templateInt_tSpec)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match
+if (not(match(x2,templateInt_tSpec))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateIntList() runs on templateInt_mycomp {
+var templateInt_rec x1,x2,x3; //value list
+x1:={ x1:=1, x2:=6, x3:=3 };
+x2:={ x1:=1, x2:=7, x3:=3 };
+x3:={ x1:=2, x2:=6, x3:=3 };
+//match
+if (match(x1,templateInt_tList)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of list
+if (not(match(x2,templateInt_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateInt_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateIntComp() runs on templateInt_mycomp {
+var templateInt_rec x1,x2,x3; //complemented list
+x1:={ x1:=1, x2:=7, x3:=3 };
+x2:={ x1:=1, x2:=6, x3:=3 };
+x3:={ x1:=2, x2:=7, x3:=3 };
+//match
+if (match(x1,templateInt_tComp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: in the list
+if (not(match(x2,templateInt_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateInt_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateIntOmit() runs on templateInt_mycomp {
+var templateInt_rec x1,x2,x3; //omitting value
+x1:={ x1:=1, x2:=2, x3:=omit };
+x2:={ x1:=1, x2:=2, x3:=3 };
+x3:={ x1:=2, x2:=2, x3:=omit };
+//match
+if (match(x1,templateInt_tOmit)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: not omitted
+if (not(match(x2,templateInt_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateInt_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateIntAny() runs on templateInt_mycomp {
+var templateInt_rec x1,x2,x3; //any value
+x1:={ x1:=1, x2:=2, x3:=3 };
+x2:={ x1:=1, x2:=2, x3:=omit };
+x3:={ x1:=2, x2:=2, x3:=3 };
+//match
+if (match(x1,templateInt_tAny)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: field omitted
+if (not(match(x2,templateInt_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateInt_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateIntAnyorNone() runs on templateInt_mycomp {
+var templateInt_rec x1,x2,x3; //AnyorNone value
+x1:={ x1:=1, x2:=2, x3:=omit };
+x2:={ x1:=1, x2:=2, x3:=3 };
+x3:={ x1:=2, x2:=2, x3:=omit };
+//match: omitted
+if (match(x1,templateInt_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: value
+if (match(x2,templateInt_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateInt_tAnyorNone))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateIntRange1() runs on templateInt_mycomp {
+var templateInt_rec x1,x2,x3; //Range (x .. y)
+x1:={ x1:=1, x2:=2, x3:=3 };
+x2:={ x1:=1, x2:=5, x3:=3 };
+x3:={ x1:=2, x2:=2, x3:=3 };
+//match
+if (match(x1,templateInt_tRange1)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of range
+if (not(match(x2,templateInt_tRange1))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateInt_tRange1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateIntRange2() runs on templateInt_mycomp {
+var templateInt_rec x1,x2,x3; //Range (x to y)
+x1:={ x1:=1, x2:=2, x3:=3 };
+x2:={ x1:=1, x2:=5, x3:=3 };
+x3:={ x1:=2, x2:=2, x3:=3 };
+//match
+if (match(x1,templateInt_tRange2)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of range
+if (not(match(x2,templateInt_tRange2))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateInt_tRange2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateIntRange3() runs on templateInt_mycomp {
+var templateInt_rec x1,x2,x3; //Range, with infinity
+x1:={ x1:=1, x2:=8, x3:=3 };
+x2:={ x1:=1, x2:=-5, x3:=3 };
+x3:={ x1:=2, x2:=2, x3:=3 };
+//match
+if (match(x1,templateInt_tRange3)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of range
+if (not(match(x2,templateInt_tRange3))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateInt_tRange3))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateIntRange4() runs on templateInt_mycomp {
+var templateInt_rec x1,x2,x3; //Range with - infinity
+x1:={ x1:=1, x2:=-2, x3:=3 };
+x2:={ x1:=1, x2:=5, x3:=3 };
+x3:={ x1:=2, x2:=2, x3:=3 };
+//match
+if (match(x1,templateInt_tRange4)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of range
+if (not(match(x2,templateInt_tRange4))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateInt_tRange4))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateIntIfpresent() runs on templateInt_mycomp {
+var templateInt_rec x1,x2,x3,x4; //ifpresent
+x1:={ x1:=1, x2:=2, x3:=3 };
+x2:={ x1:=1, x2:=2, x3:=omit };
+x3:={ x1:=1, x2:=2, x3:=4 };
+x4:={ x1:=2, x2:=2, x3:=omit };
+//match: present and match
+if (match(x1,templateInt_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: not present
+if (match(x2,templateInt_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: present and not match
+if (not(match(x3,templateInt_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x4,templateInt_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+// Types for TR_HJ94652.
+type record TR_HJ94652_myrec {
+ integer myrecint
+}
+
+template TR_HJ94652_myrec TR_HJ94652_mytemp(integer myint) := {
+ myrecint := (myint - 100 .. myint)
+}
+
+type record of TR_HJ94652_myrec TR_HJ94652_mylist
+
+testcase TR_HJ94652() runs on templateInt_mycomp {
+ // INTEGER_template::copy_template() was not implemented correctly for
+ // VALUE_RANGE templates.
+ var template TR_HJ94652_mylist myownlist := { }
+ for (var integer i := 1; i <= 3; i := i + 1) {
+ myownlist[i] := TR_HJ94652_mytemp(i * 100)
+ }
+ for (var integer i := 1; i <= 3; i := i + 1) {
+ var charstring s1 := log2str(myownlist[i])
+ var charstring s2 := log2str(TR_HJ94652_mytemp(i * 100))
+ if (s1 == s2) { setverdict(pass) }
+ else { setverdict(fail) }
+ }
+}
+
+testcase templateIntSubtype() runs on templateInt_mycomp {
+ // this tests the use of inline templates (value ranges)
+ // with subtypes and variables
+ var templateInt_subtype x := 312;
+ var templateInt_subtype lower_limit := 100;
+ var templateInt_subtype upper_limit := 65535;
+ if (not match(x, templateInt_subtype:(0..upper_limit))) { // TR: artf602477
+ setverdict(fail);
+ }
+ if (not match(x, integer:(100..upper_limit))) {
+ setverdict(fail);
+ }
+ if (not match(312, templateInt_subtype:(100..upper_limit))) {
+ setverdict(fail);
+ }
+ if (not match(x, templateInt_subtype:(100..65535))) {
+ setverdict(fail);
+ }
+ if (not match(x, templateInt_subtype:(lower_limit..65535))) {
+ setverdict(fail);
+ }
+ if (not match(x, templateInt_subtype:(lower_limit..upper_limit))) {
+ setverdict(fail);
+ }
+ setverdict(pass);
+}
+
+// test case: using a parameterized template with no actual parameters (using default values)
+// before its declaration
+template integer tReverse := tPard;
+
+template integer tPard(integer p := 6) := p;
+
+testcase templateIntReverseOrder() runs on templateInt_mycomp {
+ var template integer vtExpected := 6;
+ if (log2str(tReverse) == log2str(vtExpected)) {
+ setverdict(pass);
+ }
+ else {
+ setverdict(fail, "Expected: ", vtExpected, ", got: ", tReverse);
+ }
+}
+
+// same test, but the parameterized template is passed as a parameter to
+// an imported parameterized template
+template integer tReverse2 := tImported(tPard2);
+
+template integer tPard2(integer p := 4) := p;
+
+testcase templateIntReverseOrderImported() runs on templateInt_mycomp {
+ var template integer vtExpected := 4;
+ if (log2str(tReverse2) == log2str(vtExpected)) {
+ setverdict(pass);
+ }
+ else {
+ setverdict(fail, "Expected: ", vtExpected, ", got: ", tReverse2);
+ }
+}
+
+// same as the previous test, but with a non-parameterized template
+template integer tReverse3 := tImported(tNonPard);
+
+template integer tNonPard := (1, 2);
+
+testcase templateIntReverseOrderImported2() runs on templateInt_mycomp {
+ var template integer vtExpected := (1, 2);
+ if (log2str(tReverse3) == log2str(vtExpected)) {
+ setverdict(pass);
+ }
+ else {
+ setverdict(fail, "Expected: ", vtExpected, ", got: ", tReverse3);
+ }
+}
+
+template integer IntTemplateParam(template integer i := 3) := i;
+
+testcase templateIntParam() runs on templateInt_mycomp {
+ if (ispresent(IntTemplateParam)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (ispresent(IntTemplateParam(2))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(IntTemplateParam)) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+ if (isbound(IntTemplateParam(2))) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+}
+
+
+control {
+ execute(templateIntSpec());
+ execute(templateIntList());
+ execute(templateIntComp());
+ execute(templateIntOmit());
+ execute(templateIntAny());
+ execute(templateIntAnyorNone());
+ execute(templateIntRange1());
+ execute(templateIntRange2());
+ execute(templateIntRange3());
+ execute(templateIntRange4());
+ execute(templateIntIfpresent());
+ execute(TR_HJ94652());
+ execute(templateIntSubtype());
+ execute(templateIntReverseOrder());
+ execute(templateIntReverseOrderImported());
+ execute(templateIntReverseOrderImported2());
+ execute(templateIntParam());
+}
+}
diff --git a/Regression_Test_java/src/TtemplateRec.ttcn b/Regression_Test_java/src/TtemplateRec.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..e1e48e2edb61c12cd79a6afa6714a689a6da4cff
--- /dev/null
+++ b/Regression_Test_java/src/TtemplateRec.ttcn
@@ -0,0 +1,696 @@
+/******************************************************************************
+ * 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
+ * Delic, Adam
+ * Kovacs, Ferenc
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TtemplateRec {
+
+type record RP {
+ record of record {
+ integer i optional,
+ charstring s
+ } inner
+}
+
+type record SR { // simple record
+ integer i
+}
+
+template RP t_r_all_omit := { { { omit, "omit" } } }
+
+
+type component templateRec_mycomp {};
+type record templateRec_myrec {
+ integer f1,
+ float f2 };
+type record templateRec_rec {
+ templateRec_myrec x1,
+ templateRec_myrec x2,
+ templateRec_myrec x3 optional };
+template templateRec_rec templateRec_tSpec :={ //specific values
+ x1:={f1:=1,f2:=1.2},
+ x2:={f1:=2,f2:=1.2},
+ x3:={f1:=3,f2:=1.2} };
+template templateRec_rec templateRec_tList :={ //specific value and value list
+ x1:={f1:=1,f2:=1.2},
+ x2:=({f1:=2,f2:=1.2},{f1:=3,f2:=1.2},{f1:=6,f2:=1.2}),
+ x3:={f1:=3,f2:=1.2} };
+template templateRec_rec templateRec_tComp :={ //specific value and compl. list
+ x1:={f1:=1,f2:=1.2},
+ x2:=complement ({f1:=2,f2:=1.2},{f1:=3,f2:=1.2},{f1:=6,f2:=1.2}),
+ x3:={f1:=3,f2:=1.2} };
+template templateRec_rec templateRec_tOmit :={ //omitting values
+ x1:={f1:=1,f2:=1.2},
+ x2:={f1:=2,f2:=1.2},
+ x3:=omit } ;
+template templateRec_rec templateRec_tAny :={ //specific and any value
+ x1:={f1:=1,f2:=1.2},
+ x2:={f1:=2,f2:=1.2},
+ x3:=? } ;
+template templateRec_rec templateRec_tAnyorNone :={ //specific and AnyorNone value
+ x1:={f1:=1,f2:=1.2},
+ x2:={f1:=2,f2:=1.2},
+ x3:=* };
+template templateRec_rec templateRec_tIfpresent :={ //specific value and ifpresent
+ x1:={f1:=1,f2:=1.2},
+ x2:={f1:=2,f2:=1.2},
+ x3:={f1:=3,f2:=1.2} ifpresent };
+
+testcase pasu() runs on templateRec_mycomp
+{
+ template integer v_timeUnit := 60;
+
+ var template SR t_sr := { 13 }
+ t_sr.i := v_timeUnit;
+
+ template RP v_r modifies t_r_all_omit := {{{
+ i := v_timeUnit
+ }}}
+ setverdict(pass); // if it compiles, that's enough
+}
+
+testcase templateRecSpec() runs on templateRec_mycomp {
+var templateRec_myrec temp:={f1:=3,f2:=1.2};
+var templateRec_rec x1,x2; //specific value
+x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp };
+x2:={ x1:={f1:=2,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp };
+//match
+if (match(x1,templateRec_tSpec)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match
+if (not(match(x2,templateRec_tSpec))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecList() runs on templateRec_mycomp {
+var templateRec_myrec temp:={f1:=3,f2:=1.2};
+var templateRec_rec x1,x2,x3; //value list
+x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=6,f2:=1.2}, x3:=temp };
+x2:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=7,f2:=1.2}, x3:=temp };
+x3:={ x1:={f1:=8,f2:=1.2}, x2:={f1:=6,f2:=1.2}, x3:=temp };
+//match
+if (match(x1,templateRec_tList)) {setverdict(pass);}
+ else {setverdict(fail, 1);}
+//no match: out of list
+if (not(match(x2,templateRec_tList))) {setverdict(pass);}
+ else {setverdict(fail, 2);}
+//no match: other field
+if (not(match(x3,templateRec_tList))) {setverdict(pass);}
+ else {setverdict(fail, 3);}
+}
+
+testcase templateRecComp() runs on templateRec_mycomp {
+var templateRec_myrec temp:={f1:=3,f2:=1.2};
+var templateRec_rec x1,x2,x3; //complemented list
+x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=7,f2:=1.2}, x3:=temp };
+x2:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=6,f2:=1.2}, x3:=temp };
+x3:={ x1:={f1:=2,f2:=1.2}, x2:={f1:=7,f2:=1.2}, x3:=temp };
+//match
+if (match(x1,templateRec_tComp)) {setverdict(pass);}
+ else {setverdict(fail, 1);}
+//no match: in the list
+if (not(match(x2,templateRec_tComp))) {setverdict(pass);}
+ else {setverdict(fail, 2);}
+//no match: other field
+if (not(match(x3,templateRec_tComp))) {setverdict(pass);}
+ else {setverdict(fail, 3);}
+}
+
+testcase templateRecOmit() runs on templateRec_mycomp {
+var templateRec_myrec temp:={f1:=3,f2:=1.2};
+var templateRec_rec x1,x2,x3; //omitting value
+x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+x2:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp };
+x3:={ x1:={f1:=2,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+//match
+if (match(x1,templateRec_tOmit)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: not omitted
+if (not(match(x2,templateRec_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateRec_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecAny() runs on templateRec_mycomp {
+var templateRec_myrec temp:={f1:=3,f2:=1.2};
+var templateRec_rec x1,x2,x3; //any value
+x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp };
+x2:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+x3:={ x1:={f1:=2,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp };
+//match
+if (match(x1,templateRec_tAny)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: field omitted
+if (not(match(x2,templateRec_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateRec_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecAnyorNone() runs on templateRec_mycomp {
+var templateRec_myrec temp:={f1:=3,f2:=1.2};
+var templateRec_rec x1,x2,x3; //AnyorNone value
+x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+x2:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp };
+x3:={ x1:={f1:=2,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+//match: omitted
+if (match(x1,templateRec_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: value
+if (match(x2,templateRec_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateRec_tAnyorNone))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecIfpresent() runs on templateRec_mycomp {
+var templateRec_myrec temp1:={f1:=3,f2:=1.2}; //ifpresent
+var templateRec_myrec temp2:={f1:=4,f2:=1.2};
+var templateRec_rec x1,x2,x3,x4;
+x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp1 };
+x2:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+x3:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp2 };
+x4:={ x1:={f1:=2,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+//match: present and match
+if (match(x1,templateRec_tIfpresent)) {setverdict(pass);}
+else {setverdict(fail);}
+//match: not present
+if (match(x2,templateRec_tIfpresent)) {setverdict(pass);}
+else {setverdict(fail);}
+//no match: present and not match
+if (not(match(x3,templateRec_tIfpresent))) {setverdict(pass);}
+else {setverdict(fail);}
+//no match: other field
+if (not(match(x4,templateRec_tIfpresent))) {setverdict(pass);}
+else {setverdict(fail);}
+}
+
+
+type record R
+{
+ integer i,
+ charstring str optional
+}
+const R cr := { 1, omit }
+template R tRrec1 := { 1 , omit }
+template R tRrec2 := { 1, complement ( omit, "a" ) }
+template R tRrec3 := { 1, ( omit, "a" ) }
+template R tr := { i := 1, str := ( omit , omit ) }
+template R tr2 := { i := 1, str := complement( omit , omit ) }
+template R trc := cr; // HQ46602
+
+// Note: this tests legacy behavior and requires the -M compiler option!
+testcase MTTSM00015947() runs on templateRec_mycomp
+{
+ if (not match(cr, tRrec1)) { setverdict(fail); }
+ if (match(cr, tRrec2)) { setverdict(fail); }
+ if (not match(cr, tRrec3)) { setverdict(fail); }
+ if (ispresent(tr.str)) { setverdict(fail); }
+ if (ispresent(trc.str)) { setverdict(fail); }
+ if (not ispresent(tr2.str)) { setverdict(fail); }
+ setverdict(pass);
+}
+
+import from TtemplateRecAsn all
+template AmbiguousAnyRec t_AAR := { ''O }
+const AmbiguousAnyRec c_AAR := { ''O }
+testcase tc_HM39698() runs on templateRec_mycomp
+{
+ var template AmbiguousAnyRec vt_AAR := { ''O }
+ var AmbiguousAnyRec v_AAR := { ''O }
+ log(t_AAR)
+ log(c_AAR)
+ log(vt_AAR)
+ log(v_AAR)
+ // It's good, if we reach this point...
+ setverdict(pass)
+}
+
+testcase tc_valueof_governor_segfault() runs on templateRec_mycomp
+{
+ var templateRec_myrec mr := valueof({f1 := 1, f2 := 2.0})
+ setverdict(pass)
+}
+
+// Parametrized template reference without `()'.
+template R tmr(in integer i := 1) := { i := i, str := omit }
+testcase tc_HO49372() runs on templateRec_mycomp
+{
+ log(tmr)
+ setverdict(pass)
+}
+
+type record MyRecord
+{
+ integer int,
+ boolean deleted
+}
+testcase tc_HO69658() runs on templateRec_mycomp
+{
+var template MyRecord vl_myrecord;
+vl_myrecord.int := 0;
+
+var template MyRecord vl_myrecordAgain := vl_myrecord;
+vl_myrecordAgain.deleted := false;
+
+log("Now assignment finish");
+log("Print record:",vl_myrecordAgain);
+// It's good, if we reach this point...
+if (log2str(vl_myrecordAgain)=="{ int := 0, deleted := false }") {setverdict(pass)}else{setverdict(fail)}
+}
+
+type record MyRec2{
+ ROC roc optional,
+ ROI roi optional,
+ MyUnion1 u optional,
+ MyRecord1 r optional
+}
+
+type record of charstring ROC;
+type record of integer ROI;
+type record MyRecord1 {
+ integer i optional,
+ float x optional,
+ charstring c
+}
+
+type union MyUnion1 {
+ ROC roc,
+ integer i,
+ ROI roi,
+ MyRecord1 r
+}
+
+ type union MyUnion_OneOption {
+ integer i
+ }
+
+ type record MyRec4 {
+ MyUnion_OneOption u,
+ integer i
+ }
+
+testcase tc_record_withJoker1() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2_j;
+ if(isbound(vtl_rec2_j)) {setverdict(fail)}else {setverdict(pass)};
+ vtl_rec2_j:={
+ roc:=*
+ }
+ if(isbound(vtl_rec2_j)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.roc)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.roc[0])) {setverdict(fail)}else {setverdict(pass)};
+}
+testcase tc_record_withJoker2() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2_j;
+ vtl_rec2_j:={
+ roc:={ ?,? }
+ }
+ if(isbound(vtl_rec2_j)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.roc)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.roc[0])){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.roc[1])){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.roc[10])){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.roi)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.u)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.r)){setverdict(fail)}else {setverdict(pass)};
+}
+
+testcase tc_record_withJoker3() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2_j;
+ vtl_rec2_j:={
+ u := *
+ }
+ if(isbound(vtl_rec2_j)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.roc)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.roi)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.u)){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.u.i)){setverdict(fail)}else {setverdict(pass)};
+}
+
+testcase tc_record_withJoker4() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2_j;
+ vtl_rec2_j:={
+ roc:=omit,
+ u:={i:=?}
+ }
+ if(isbound(vtl_rec2_j)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.roc)){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.roi)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.u)){setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.u.i)){setverdict(pass)}else {setverdict(fail)};
+}
+
+testcase tc_record_withJoker5() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2_j;
+ vtl_rec2_j:={
+ r:= ?
+ }
+ if(isbound(vtl_rec2_j)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.roc)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.roi)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.u)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.u.i)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.r)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.r.i)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.r.x)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.r.c)) {setverdict(pass)}else {setverdict(fail)};
+}
+
+testcase tc_record_withJoker6() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2_j;
+ vtl_rec2_j:={
+ r:= *
+ }
+ if(isbound(vtl_rec2_j)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.roc)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.roi)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.u)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.u.i)){setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.r)) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound(vtl_rec2_j.r.i)) {setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.r.x)) {setverdict(fail)}else {setverdict(pass)};
+ if(isbound(vtl_rec2_j.r.c)) {setverdict(fail)}else {setverdict(pass)};
+}
+
+group g_TR_HO72812 {
+ type record MyRecord_HO72812
+ {
+ record {
+ boolean innerField1 optional,
+ integer innerField2 optional
+ } field1 optional,
+ integer field2
+ }
+ testcase tc_record_TR_HO72813() runs on templateRec_mycomp {
+ var MyRecord_HO72812 vl_MyRecord := { field1 := {}, field2 := 5 };
+ if(isbound(vl_MyRecord)) {setverdict(pass)} else {setverdict(fail)}
+ if(isbound(vl_MyRecord.field1)) {setverdict(fail)} else {setverdict(pass)}
+ if(isbound(vl_MyRecord.field2)) {setverdict(pass)} else {setverdict(fail)}
+ vl_MyRecord.field1 := omit
+ if(isbound(vl_MyRecord.field1)) {setverdict(pass)} else {setverdict(fail)}
+ if(isbound(vl_MyRecord.field1.innerField1)) {setverdict(fail)} else {setverdict(pass)}
+ if(isbound(vl_MyRecord.field1.innerField1)) {setverdict(fail)} else {setverdict(pass)}
+ if(ispresent(vl_MyRecord.field1)) {setverdict(fail)} else {setverdict(pass)}
+
+ vl_MyRecord := { field1 := {innerField1:=true, innerField2:=1 } }
+ if(isbound(vl_MyRecord.field1)) {setverdict(pass)} else {setverdict(fail)}
+ if(isbound(vl_MyRecord.field1.innerField1)) {setverdict(pass)} else {setverdict(fail)}
+ if(isbound(vl_MyRecord.field1.innerField2)) {setverdict(pass)} else {setverdict(fail)}
+ }
+ testcase tc_record_TR_HO72813_ip() runs on templateRec_mycomp {
+ var MyRecord_HO72812 vl_MyRecord := { field1 := {}, field2 := 5 };
+ if(ispresent(vl_MyRecord)) {setverdict(pass)} else {setverdict(fail)}
+ if(ispresent(vl_MyRecord.field1)) {setverdict(fail)} else {setverdict(pass)} //according to ethgry
+ if(ispresent(vl_MyRecord.field2)) {setverdict(pass)} else {setverdict(fail)}
+ }
+
+ testcase tc_record_TR_HO72813_innerFields() runs on templateRec_mycomp {
+ var MyRecord_HO72812 vl_MyRecord := { field1 := {}, field2 := 5 };
+ if(ispresent(vl_MyRecord.field1.innerField1)) {setverdict(fail)} else {setverdict(pass)}
+ if(ispresent(vl_MyRecord.field1.innerField2)) {setverdict(fail)} else {setverdict(pass)}
+ }
+
+ testcase tc_record_TR_HO72813_partlyInitialized() runs on templateRec_mycomp {
+ var MyRecord_HO72812 vl_MyRecord := { field1 := {innerField1:=true}, field2 := 5 };
+ if(ispresent(vl_MyRecord.field1)) {setverdict(pass)} else {setverdict(fail)} ;
+ if(ispresent(vl_MyRecord.field1.innerField1)) {setverdict(pass)} else {setverdict(fail)};
+ if(ispresent(vl_MyRecord.field1.innerField2)) {setverdict(fail)} else {setverdict(pass)} ; //DTE???
+ }
+
+ testcase tc_record_TR_HO72813_omit() runs on templateRec_mycomp {
+ var MyRecord_HO72812 vl_MyRecord := { field1 := {innerField1:=true}, field2 := 5 }
+ vl_MyRecord.field1 := omit;
+ if(ispresent(vl_MyRecord.field1)) {setverdict(fail)} else {setverdict(pass)}
+ if(ispresent(vl_MyRecord.field1.innerField1)) {setverdict(fail)} else {setverdict(pass)};
+ if(ispresent(vl_MyRecord.field1.innerField2)) {setverdict(fail)} else {setverdict(pass)} ; //DTE???
+ }
+}
+
+ testcase tc_record_mandatoryField_WithWildcard() runs on templateRec_mycomp {
+ var template MyRec4 vtl_rec:=?
+ if(ispresent(vtl_rec.u)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vtl_rec.i)){setverdict(pass)}else {setverdict(fail)};
+ }
+
+ testcase tc_record_withWildCard1() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ roc:=*
+ }
+ if(ispresent(vtl_rec2)) {setverdict(pass)}else {setverdict(fail)};
+ }
+ testcase tc_record_withWildCard1A() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ roc:=*
+ }
+ if(ispresent(vtl_rec2.roc)) {setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_withWildCard1AA() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ roc:=?
+ }
+ if(ispresent(vtl_rec2.roc)) {setverdict(pass)}else {setverdict(fail)};
+ }
+
+ testcase tc_record_withWildCard1B() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ roc:=*
+ }
+ if(ispresent(vtl_rec2.roc[0])) {setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_withWildCard2() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ roc:={ ?,? }
+ }
+ if(ispresent(vtl_rec2)) {setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vtl_rec2.roc)) {setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vtl_rec2.roc[0])){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vtl_rec2.roc[1])){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vtl_rec2.roc[10])){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ //unbound
+ testcase tc_record_withWildCard2A() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ roc:={ ?,? }
+ }
+ if(ispresent(vtl_rec2.roi)){setverdict(fail)}else {setverdict(pass)};
+ }
+ testcase tc_record_withWildCard2B() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ roc:={ ?,? }
+ }
+ if(ispresent(vtl_rec2.u)){setverdict(fail)}else {setverdict(pass)};
+ }
+ testcase tc_record_withWildCard2C() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ roc:={ ?,? }
+ }
+ if(ispresent(vtl_rec2.r)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_withWildCard3() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ u := *
+ }
+ if(ispresent(vtl_rec2)) {setverdict(pass)}else {setverdict(fail)};
+ }
+
+ testcase tc_record_withWildCard3A() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ u := *
+ }
+ if(ispresent(vtl_rec2.roc)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_withWildCard3B() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ u := *
+ }
+ if(ispresent(vtl_rec2.roi)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_withWildCard3C() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ u := *
+ }
+ if(ispresent(vtl_rec2.u)){setverdict(fail)}else{setverdict(pass)};
+ }
+
+ testcase tc_record_withWildCard3D() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ u := ?
+ }
+ if(ispresent(vtl_rec2.u)){setverdict(pass)}else{setverdict(fail)};
+ }
+
+ testcase tc_record_withWildCard4() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ roc:=omit,
+ u:={i:=?}
+ }
+ if(ispresent(vtl_rec2)) {setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vtl_rec2.roc)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_withWildCard4A() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ roc:=omit,
+ u:={i:=?}
+ }
+ if(ispresent(vtl_rec2.roi)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_withWildCard4B() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ roc:=omit,
+ u:={i:=?}
+ }
+ if(ispresent(vtl_rec2.u)){setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vtl_rec2.u.i)){setverdict(pass)}else {setverdict(fail)};
+ }
+
+ testcase tc_record_withWildCard5() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ r:= ?
+ }
+ if(ispresent(vtl_rec2)) {setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vtl_rec2.roc)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vtl_rec2.roi)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vtl_rec2.u)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vtl_rec2.u.i)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_withWildCard5A() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ r:= ?
+ }
+ if(ispresent(vtl_rec2.r)) {setverdict(pass)}else {setverdict(fail)};
+ }
+
+ testcase tc_record_withWildCard5B_optional() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ r:= ?
+ }
+ if(ispresent(vtl_rec2.r.i)) {setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vtl_rec2.r.x)) {setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_withWildCard5B_mandatory() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ r:= ?
+ }
+ if(ispresent(vtl_rec2.r.c)) {setverdict(pass)}else {setverdict(fail)};
+ }
+
+ testcase tc_record_withWildCard6() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ r:= *
+ }
+ if(ispresent(vtl_rec2)) {setverdict(pass)}else {setverdict(fail)};
+ if(ispresent(vtl_rec2.roc)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vtl_rec2.roi)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vtl_rec2.u)){setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vtl_rec2.u.i)){setverdict(fail)}else {setverdict(pass)};
+ }
+
+ testcase tc_record_withWildCard6A() runs on templateRec_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={
+ r:= *
+ }
+ if(ispresent(vtl_rec2.r)) {setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vtl_rec2.r.i)) {setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vtl_rec2.r.x)) {setverdict(fail)}else {setverdict(pass)};
+ if(ispresent(vtl_rec2.r.c)) {setverdict(fail)}else {setverdict(pass)};
+ }
+
+control {
+ execute(pasu());
+ execute(templateRecSpec());
+ execute(templateRecList());
+ execute(templateRecComp());
+ execute(templateRecOmit());
+ execute(templateRecAny());
+ execute(templateRecAnyorNone());
+ execute(templateRecIfpresent());
+ execute(MTTSM00015947());
+ execute(tc_HM39698());
+ execute(tc_valueof_governor_segfault());
+ execute(tc_HO49372());
+ execute(tc_HO69658());
+
+ execute(tc_record_withJoker1());
+ execute(tc_record_withJoker2());
+ execute(tc_record_withJoker3());
+ execute(tc_record_withJoker4());
+ execute(tc_record_withJoker5());
+ execute(tc_record_withJoker6());
+ execute(tc_record_TR_HO72813());
+ execute(tc_record_withWildCard1());
+ execute(tc_record_withWildCard1A()); //pass
+ execute(tc_record_withWildCard1AA());
+ execute(tc_record_withWildCard1B());
+ execute(tc_record_withWildCard2());
+ execute(tc_record_withWildCard2A());//pass (unbound)
+ execute(tc_record_withWildCard2B());//pass (unbound)
+ execute(tc_record_withWildCard2C());//pass (unbound)
+ execute(tc_record_withWildCard3());
+ execute(tc_record_withWildCard3A());//pass (unbound)
+ execute(tc_record_withWildCard3B());//pass (unbound)
+ execute(tc_record_withWildCard3C());//pass (*)
+ execute(tc_record_withWildCard3D());//pass
+ execute(tc_record_withWildCard4());//pass
+ execute(tc_record_withWildCard4A());
+ execute(tc_record_withWildCard4B());
+ execute(tc_record_withWildCard5());//pass
+ execute(tc_record_withWildCard5A());//pass
+ execute(tc_record_withWildCard5A());//pass
+ execute(tc_record_withWildCard5B_optional());//pass
+ execute(tc_record_withWildCard5B_mandatory());//pass
+ execute(tc_record_withWildCard6());//pass
+ execute(tc_record_withWildCard6A());
+ execute(tc_record_TR_HO72813_ip());
+ execute(tc_record_TR_HO72813_innerFields());
+ execute(tc_record_TR_HO72813_partlyInitialized());
+ execute(tc_record_TR_HO72813_omit());
+}
+}
diff --git a/Regression_Test_java/src/TtemplateRecAsn.asn b/Regression_Test_java/src/TtemplateRecAsn.asn
new file mode 100644
index 0000000000000000000000000000000000000000..0e2bfb929cc1cf6e552687b6f85cb4a2a9656730
--- /dev/null
+++ b/Regression_Test_java/src/TtemplateRecAsn.asn
@@ -0,0 +1,22 @@
+--/////////////////////////////////////////////////////////////////////////////
+-- 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
+--
+--/////////////////////////////////////////////////////////////////////////////
+TtemplateRecAsn
+DEFINITIONS IMPLICIT TAGS ::= BEGIN
+IMPORTS ;
+-- Test for HM39698.
+AmbiguousAnyRec ::= SEQUENCE
+{
+ argument ANY OPTIONAL
+}
+END
+
diff --git a/Regression_Test_java/src/TtemplateRecof.ttcn b/Regression_Test_java/src/TtemplateRecof.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..49a1a2262cf82c818cc6bcc897ce3dcbbe2e33db
--- /dev/null
+++ b/Regression_Test_java/src/TtemplateRecof.ttcn
@@ -0,0 +1,682 @@
+/******************************************************************************
+ * 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
+ * Delic, Adam
+ * Forstner, Matyas
+ * Kovacs, Ferenc
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TtemplateRecof {
+type component mycomp {};
+type record of integer templateRecof_myrecof;
+type record templateRecof_rec {
+ templateRecof_myrecof x1,
+ templateRecof_myrecof x2,
+ templateRecof_myrecof x3 optional };
+template templateRecof_rec templateRecof_tSpec :={ //specific values
+ x1:={1,1},
+ x2:={2,1},
+ x3:={3,1} };
+template templateRecof_rec templateRecof_tList :={ //specific value and value list
+ x1:={1,1},
+ x2:=({2,1},{3,1},{6,1}),
+ x3:={3,1} };
+template templateRecof_rec templateRecof_tComp :={ //specific value and compl. list
+ x1:={1,1},
+ x2:=complement ({2,1},{3,1},{6,1}),
+ x3:={3,1} };
+template templateRecof_rec templateRecof_tOmit :={ //omitting values
+ x1:={1,1},
+ x2:={2,1},
+ x3:=omit } ;
+template templateRecof_rec templateRecof_tAny :={ //specific and any value
+ x1:={1,1},
+ x2:={2,1},
+ x3:=? } ;
+template templateRecof_rec templateRecof_tAnyorNone :={ //specific and AnyorNone value
+ x1:={1,1},
+ x2:={2,1},
+ x3:=* };
+template templateRecof_rec templateRecof_tLength1 :={ //specific value and length (fix)
+ x1:={1,1},
+ x2:={2,1},
+ x3:=* length(3) };
+template templateRecof_rec templateRecof_tLength2 :={ //specific value and length (range)
+ x1:={1,1},
+ x2:={2,1},
+ x3:=? length(2..4) };
+template templateRecof_rec templateRecof_tLength3 :={ //specific value and length (range, infinity)
+ x1:={1,1},
+ x2:={2,1},
+ x3:=? length(2..infinity) };
+template templateRecof_rec templateRecof_tIfpresent :={ // specific value and ifpresent
+ x1:={1,1},
+ x2:={2,1},
+ x3:={3,1} ifpresent };
+template templateRecof_rec templateRecof_tLengthIfp :={ //specific value and length (fix), ifpresent
+ x1:={1,1},
+ x2:={2,1},
+ x3:=? length(3) ifpresent};
+template templateRecof_rec templateRecof_tAnyEl :={ //specific value and any element inside value
+ x1:={1,1},
+ x2:={2,1},
+ x3:={3,?,1} } ;
+template templateRecof_rec templateRecof_tAnyorNoneEl :={ //specific value and Any number of elements or none inside value
+ x1:={1,1},
+ x2:={2,1},
+ x3:={3,*,1} };
+
+template templateRecof_rec aliased_template := templateRecof_tAnyorNoneEl;
+
+testcase templateRecofSpec() runs on mycomp {
+var templateRecof_myrecof temp:={3,1};
+var templateRecof_rec x1,x2; //specific value
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp };
+x2:={ x1:={2,1}, x2:={2,1}, x3:=temp };
+//match
+if (match(x1,templateRecof_tSpec)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match
+if (not(match(x2,templateRecof_tSpec))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecofList() runs on mycomp {
+var templateRecof_myrecof temp:={3,1};
+var templateRecof_rec x1,x2,x3; //value list
+x1:={ x1:={1,1}, x2:={6,1}, x3:=temp };
+x2:={ x1:={1,1}, x2:={7,1}, x3:=temp };
+x3:={ x1:={8,1}, x2:={6,1}, x3:=temp };
+//match
+if (match(x1,templateRecof_tList)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of list
+if (not(match(x2,templateRecof_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateRecof_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecofComp() runs on mycomp {
+var templateRecof_myrecof temp:={3,1};
+var templateRecof_rec x1,x2,x3; //complemented list
+x1:={ x1:={1,1}, x2:={7,1}, x3:=temp };
+x2:={ x1:={1,1}, x2:={6,1}, x3:=temp };
+x3:={ x1:={2,1}, x2:={7,1}, x3:=temp };
+//match
+if (match(x1,templateRecof_tComp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: in the list
+if (not(match(x2,templateRecof_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateRecof_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecofOmit() runs on mycomp {
+var templateRecof_myrecof temp:={3,1};
+var templateRecof_rec x1,x2,x3; //omitting value
+x1:={ x1:={1,1}, x2:={2,1}, x3:=omit };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=temp };
+x3:={ x1:={2,1}, x2:={2,1}, x3:=omit };
+//match
+if (match(x1,templateRecof_tOmit)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: not omitted
+if (not(match(x2,templateRecof_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateRecof_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecofAny() runs on mycomp {
+var templateRecof_myrecof temp:={3,1};
+var templateRecof_rec x1,x2,x3; //any value
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=omit };
+x3:={ x1:={2,1}, x2:={2,1}, x3:=temp };
+//match
+if (match(x1,templateRecof_tAny)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: field omitted
+if (not(match(x2,templateRecof_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateRecof_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecofAnyorNone() runs on mycomp {
+var templateRecof_myrecof temp:={3,1};
+var templateRecof_rec x1,x2,x3; //AnyorNone value
+x1:={ x1:={1,1}, x2:={2,1}, x3:=omit };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=temp };
+x3:={ x1:={2,1}, x2:={2,1}, x3:=omit };
+//match: omitted
+if (match(x1,templateRecof_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: value
+if (match(x2,templateRecof_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateRecof_tAnyorNone))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecofLength1() runs on mycomp {
+var templateRecof_myrecof temp1:={1,2,3}; //length (fix)
+var templateRecof_myrecof temp2:={1,2};
+var templateRecof_rec x1,x2,x3,x4;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=omit };
+x3:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x4:={ x1:={1,1,1}, x2:={2,1}, x3:=temp1 };
+//match: proper length
+if (match(x1,templateRecof_tLength1)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: omitted
+if (match(x2,templateRecof_tLength1)) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: not proper length
+if (not(match(x3,templateRecof_tLength1))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x4,templateRecof_tLength1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecofLength2() runs on mycomp {
+var templateRecof_myrecof temp1:={1,2}; // length (range)
+var templateRecof_myrecof temp2:={1};
+var templateRecof_rec x1,x2,x3;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x3:={ x1:={1}, x2:={2,1}, x3:=temp1 };
+//match
+if (match(x1,templateRecof_tLength2)) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: not proper length
+if (not(match(x2,templateRecof_tLength2))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateRecof_tLength2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecofLength3() runs on mycomp {
+var templateRecof_myrecof temp1:={1,2}; // length (range, infinity)
+var templateRecof_myrecof temp2:={1};
+var templateRecof_rec x1,x2,x3;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x3:={ x1:={1}, x2:={2,1}, x3:=temp1 };
+//match
+if (match(x1,templateRecof_tLength3)) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: not proper length
+if (not(match(x2,templateRecof_tLength3))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateRecof_tLength3))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecofIfpresent() runs on mycomp {
+var templateRecof_myrecof temp1:={3,1}; //ifpresent
+var templateRecof_myrecof temp2:={4,1};
+var templateRecof_rec x1,x2,x3,x4;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=omit };
+x3:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x4:={ x1:={2,1}, x2:={2,1}, x3:=omit };
+//match: present and match
+if (match(x1,templateRecof_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: not present
+if (match(x2,templateRecof_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: present and not match
+if (not(match(x3,templateRecof_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x4,templateRecof_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecofLengthIfp() runs on mycomp {
+var templateRecof_myrecof temp1:={1,2,3}; //length (fix), ifpresent
+var templateRecof_myrecof temp2:={1,2};
+var templateRecof_rec x1,x2,x3,x4;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=omit };
+x3:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x4:={ x1:={1,1,1}, x2:={2,1}, x3:=temp1 };
+//match: proper length
+if (match(x1,templateRecof_tLengthIfp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: omitted
+if (match(x2,templateRecof_tLengthIfp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: not proper length
+if (not(match(x3,templateRecof_tLengthIfp))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x4,templateRecof_tLengthIfp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecofAnyEl() runs on mycomp {
+var templateRecof_myrecof temp1:={3,15,1}; // any element
+var templateRecof_myrecof temp2:={3,1};
+var templateRecof_myrecof temp3:={3,1,4,1};
+var templateRecof_myrecof temp4:={3,1,2};
+var templateRecof_rec x1,x2,x3,x4,x5;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x3:={ x1:={1,1}, x2:={2,1}, x3:=temp3 };
+x4:={ x1:={1,1}, x2:={2,1}, x3:=temp4 };
+x5:={ x1:={1}, x2:={2,1}, x3:=temp1 };
+//match
+if (match(x1,templateRecof_tAnyEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: no element
+if (not(match(x2,templateRecof_tAnyEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: two element
+if (not(match(x3,templateRecof_tAnyEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: wrong element
+if (not(match(x4,templateRecof_tAnyEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x5,templateRecof_tAnyEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateRecofAnyorNoneEl() runs on mycomp {
+var templateRecof_myrecof temp1:={3,1}; //Any number of elements or none
+var templateRecof_myrecof temp2:={3,5,1};
+var templateRecof_myrecof temp3:={3,2,5,1};
+var templateRecof_myrecof temp4:={4,2,1};
+var templateRecof_myrecof temp5:={3,5,1,2,1};
+var templateRecof_myrecof temp6:={3,5,1,2};
+var templateRecof_rec x1,x2,x3,x4,x5,x6,x7;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x3:={ x1:={1,1}, x2:={2,1}, x3:=temp3 };
+x4:={ x1:={1,1}, x2:={2,1}, x3:=temp4 };
+x5:={ x1:={1,2}, x2:={2,1}, x3:=temp3 };
+x6:={ x1:={1,1}, x2:={2,1}, x3:=temp5 };
+x7:={ x1:={1,1}, x2:={2,1}, x3:=temp6 };
+//match: no element
+if (match(x1,templateRecof_tAnyorNoneEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: one element
+if (match(x2,templateRecof_tAnyorNoneEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: two element
+if (match(x3,templateRecof_tAnyorNoneEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+//see if the algorithm goes till the end
+if (match(x6,templateRecof_tAnyorNoneEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+ //no match: other element
+if (not(match(x4,templateRecof_tAnyorNoneEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x5,templateRecof_tAnyorNoneEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+//see if the algorithm goes till the end
+if (not(match(x7,templateRecof_tAnyorNoneEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+ testcase templateRecofPermutation() runs on mycomp {
+ template templateRecof_rec t1 := {
+ {1,1},
+ {permutation(1,2,3)},
+ {3,1}
+ };
+ template templateRecof_rec t2 := {
+ {1,1},
+ {permutation(1,2,3), 4},
+ {3,1}
+ };
+ template templateRecof_rec t3 := {
+ {1,1},
+ {permutation(1,2,3,*), 4},
+ {3,1}
+ };
+ template templateRecof_rec t4 := {
+ {1,1},
+ {permutation(1,2,?,*), 4},
+ {3,1}
+ };
+ template templateRecof_rec t5 := {
+ {1,1},
+ {permutation(1,2,?), 4},
+ {3,1}
+ };
+ template templateRecof_rec t6 := {
+ {1,1},
+ {permutation(1,2,?,?), 4},
+ {3,1}
+ };
+ template templateRecof_rec t7 := {
+ {1,1},
+ {permutation(?,1,2,?), 4},
+ {3,1}
+ };
+ template templateRecof_rec t8 := {
+ {1,1},
+ {permutation(8,1,2,?), 4},
+ {3,1}
+ };
+ template templateRecof_rec t9 := {
+ {1,1},
+ {permutation(1,*,2,3,*), 4},
+ {3,1}
+ };
+ template templateRecof_rec t10 := {
+ {1,1},
+ {*, permutation(2,3,*), *},
+ {3,1}
+ };
+ template templateRecof_rec t11 := {
+ {1,1},
+ {*, permutation(2,3), *},
+ {3,1}
+ };
+ template templateRecof_rec t12 := {
+ {1,1},
+ {*, permutation(2,3,*), *, 4},
+ {3,1}
+ };
+ template templateRecof_rec t13 := {
+ {1,1},
+ {*, permutation(2,3,*), *, 4, *},
+ {3,1}
+ };
+ template templateRecof_rec t14 := {
+ {1,1},
+ {*, permutation(2,?), *, 4, *},
+ {3,1}
+ };
+ template templateRecof_rec t15 := {
+ {1,1},
+ {*, permutation(2,?), ?, 4, *},
+ {3,1}
+ };
+ template templateRecof_rec t16 := {
+ {1,1},
+ {1, *, permutation(3,?), ?, 4, *},
+ {3,1}
+ };
+ template templateRecof_rec t17 := {
+ {1,1},
+ {1, *, permutation(3,?), ?, *},
+ {3,1}
+ };
+ template templateRecof_rec t18 := {
+ {1,1},
+ {permutation(3,?), permutation(4, *)},
+ {3,1}
+ };
+ template templateRecof_rec t19 := {
+ {1,1},
+ {?, permutation(3,?), permutation(4, *)},
+ {3,1}
+ };
+ template templateRecof_rec t20 := {
+ {1,1},
+ {permutation(2,1), permutation(4,3)},
+ {3,1}
+ };
+ var templateRecof_rec v1 := {x1:={1,1}, x2:={1,2,3}, x3:={3,1}};
+ var templateRecof_rec v2 := {x1:={1,1}, x2:={2,3,1}, x3:={3,1}};
+ var templateRecof_rec v3 := {x1:={1,1}, x2:={1,2,3,4}, x3:={3,1}};
+
+ if(match(v1,t1)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v2,t1)) {setverdict(pass);} else {setverdict(fail);}
+ if(not match(v3,t1)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t2)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t3)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t4)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t5)) {setverdict(pass);} else {setverdict(fail);}
+ if(not match(v3,t6)) {setverdict(pass);} else {setverdict(fail);}
+ if(not match(v3,t7)) {setverdict(pass);} else {setverdict(fail);}
+ if(not match(v3,t8)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t9)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t10)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t11)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t12)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t13)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t14)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t15)) {setverdict(pass);} else {setverdict(fail);}
+ if(not match(v3,t16)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t17)) {setverdict(pass);} else {setverdict(fail);}
+ if(not match(v3,t18)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t19)) {setverdict(pass);} else {setverdict(fail);}
+ if(match(v3,t20)) {setverdict(pass);} else {setverdict(fail);}
+ }
+
+ type record r_A { charstring f1 }
+ type record of r_A ro_B
+ testcase HK38721() runs on mycomp {
+ var ro_B v_B := { { "" } }
+ // 3.0.4 was unable to compile the generated code for this.
+ log(match("", v_B[0].f1))
+ setverdict(pass)
+ }
+
+testcase templateRecofIsvalue() runs on mycomp {
+ var template templateRecof_myrecof tpl1;
+ var template templateRecof_myrecof tpl2 := { 0,1,2,3,4,5,6,7,8,9 }
+ template templateRecof_myrecof tpl3 := { *,?,*,?,*,?,*,?,*,? };
+ template templateRecof_myrecof tpl4 := { (0,1,2,3),*,?,*,?,*,?,*,?,42 };
+
+ if ( isvalue(tpl1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(tpl2) ) { setverdict(pass); } else { setverdict(fail); }
+ if ( isvalue(tpl3) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(tpl4) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+type record of charstring ROC;
+type record of integer ROI;
+type record MyRecord1 {
+ integer i optional,
+ float x optional,
+ charstring c
+}
+
+type union MyUnion1 {
+ ROC roc,
+ integer i,
+ ROI roi,
+ MyRecord1 r
+}
+
+type record MyRec2 {
+ ROC roc optional,
+ ROI roi optional,
+ MyUnion1 u optional,
+ MyRecord1 r optional
+}
+
+type record of MyRec2 MyRecOf
+
+template MyRecOf t_recOf1 := (
+ { [0]:= { roc:=omit }, [1]:= {roc:=omit} },
+ { [0]:= { roc:=omit }, [1]:= {roc:={"one", "two"}} },
+ { [0]:= { roc:=omit }, [2]:= {u:={i:=5}} }
+)
+
+testcase tc_recordOf_template1() runs on mycomp {
+ var template MyRecOf vtl_recOf:= t_recOf1;
+ if(isbound( vtl_recOf )) {setverdict(pass)}else {setverdict(fail)};
+ if(isbound( t_recOf1 )) {setverdict(pass)}else {setverdict(fail)};
+}
+
+testcase tc_recordOf_template2() runs on mycomp {
+ var template MyRecOf vtl_recOf:= t_recOf1;
+ if(isbound( vtl_recOf[0] )) {setverdict(fail)}else {setverdict(pass)};
+ if(isbound( vtl_recOf[1] )) {setverdict(fail)}else {setverdict(pass)};
+ if(isbound( vtl_recOf[2] )) {setverdict(fail)}else {setverdict(pass)};
+}
+
+testcase tc_recordOf_template1_ispresent() runs on mycomp {
+ var template MyRecOf vtl_recOf:= t_recOf1;
+ if(ispresent( vtl_recOf )) {setverdict(pass)}else {setverdict(fail)};
+ if(ispresent( t_recOf1 )) {setverdict(pass)}else {setverdict(fail)};
+}
+
+testcase tc_recordOf_template2_ispresent() runs on mycomp {
+ var template MyRecOf vtl_recOf:= t_recOf1;
+ if(ispresent( vtl_recOf[0] )) {setverdict(fail)}else {setverdict(pass)};
+ if(ispresent( vtl_recOf[1] )) {setverdict(fail)}else {setverdict(pass)};
+ if(ispresent( vtl_recOf[2] )) {setverdict(fail)}else {setverdict(pass)};
+}
+
+testcase tc_recordOf_template_unbound_elements_lengthof_sizeof() runs on mycomp {
+ var ROI temp;
+ var template ROI ttemp;
+ temp[99] := 0;
+ ttemp[99] := 0;
+ if ((sizeof(temp)==100) and (sizeof(temp)==sizeof(ttemp))) { setverdict(pass); } else { setverdict(fail); }
+ if ((lengthof(temp)==100) and (lengthof(temp)==lengthof(ttemp))) { setverdict(pass); } else { setverdict(fail); }
+}
+
+type record Block {}
+
+type record of Block Blocks;
+
+type record Request {
+ Blocks blocks optional
+}
+
+testcase HO91743() runs on mycomp {
+ var template Request vt_ReqO := { blocks := omit };
+ var template Request vt_ReqQ := { blocks := ? };
+ var template Request vt_ReqS := { blocks := * };
+ var template Block vt_b := {}
+
+ vt_ReqQ.blocks[3] := vt_b;
+ vt_ReqS.blocks[3] := vt_b;
+ // Indexing a template record-of which was omit used to DTE
+ // (in contrast to any-value and any-or-omit, which would create the record-of).
+ // HO91743 unifies the behaviour (record-of is created when indexing omit).
+ vt_ReqO.blocks[3] := vt_b;
+
+ if (lengthof(vt_ReqO.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
+ if (sizeof (vt_ReqO.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
+
+ if (lengthof(vt_ReqQ.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
+ if (sizeof (vt_ReqQ.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
+
+ if (lengthof(vt_ReqS.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
+ if (sizeof (vt_ReqS.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
+}
+
+//=================================================================
+// isbound tests for ROI
+function f_isbound4ROI_getLen(template ROI pl_roi) return integer {
+ var integer i := 0;
+ while(isbound(pl_roi[i])){
+ i:=i+1;
+ }
+ return i;
+}
+
+template ROI t_il0:={};
+template ROI t_il1:={0};
+template ROI t_il2:={0,*};
+template ROI t_il3:={0,?};
+template ROI t_il4:={0,1,2,3,?};
+
+function f(template ROI roi,integer expected){
+ var integer index:= f_isbound4ROI_getLen(roi);
+ if(index==expected) {
+ setverdict(pass,"Result:", index);
+ }else {
+ setverdict(fail,"Result:",index," expected:", expected);
+ }
+}
+
+testcase tc_isbound4ROI0() runs on mycomp {
+ f(t_il0,0);
+}
+
+testcase tc_isbound4ROI1() runs on mycomp {
+ f(t_il1,1);
+}
+
+testcase tc_isbound4ROI2() runs on mycomp {
+ f(t_il2,2);
+}
+
+testcase tc_isbound4ROI3() runs on mycomp {
+ f(t_il3,2);
+}
+
+testcase tc_isbound4ROI4() runs on mycomp {
+ f(t_il4,5);
+}
+
+template integer tpard(template integer i) := i;
+
+testcase tc_HU56425() runs on mycomp {
+ template integer t_i := tpard(3);
+ template templateRecof_myrecof t_list := { tpard(t_i) };
+ // HU56425 refers to a code generation error (which caused a C++ compilation error), but let's check the resulting template anyway
+ template templateRecof_myrecof t_list_exp := { 3 };
+ if (log2str(t_list) == log2str(t_list_exp)) { setverdict(pass); }
+ else { setverdict(fail); }
+}
+
+
+control {
+ execute(templateRecofSpec());
+ execute(templateRecofList());
+ execute(templateRecofComp());
+ execute(templateRecofOmit());
+ execute(templateRecofAny());
+ execute(templateRecofAnyorNone());
+ execute(templateRecofLength1());
+ execute(templateRecofLength2());
+ execute(templateRecofLength3());
+ execute(templateRecofIfpresent());
+ execute(templateRecofLengthIfp());
+ execute(templateRecofAnyEl());
+ execute(templateRecofAnyorNoneEl());
+ execute(templateRecofPermutation());
+ execute(HK38721());
+ execute(templateRecofIsvalue());
+
+ execute(tc_recordOf_template1());
+ execute(tc_recordOf_template2());
+ execute(tc_recordOf_template1_ispresent());
+ execute(tc_recordOf_template2_ispresent());
+
+ execute(tc_recordOf_template_unbound_elements_lengthof_sizeof());
+ execute(HO91743());
+ execute(tc_isbound4ROI0());
+ execute(tc_isbound4ROI1());
+ execute(tc_isbound4ROI2());
+ execute(tc_isbound4ROI3());
+ execute(tc_isbound4ROI4());
+
+}
+}
diff --git a/Regression_Test_java/src/TtemplateSet.ttcn b/Regression_Test_java/src/TtemplateSet.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..ca5a9e5f242ef83b5a3be48a6941258bb671cdcc
--- /dev/null
+++ b/Regression_Test_java/src/TtemplateSet.ttcn
@@ -0,0 +1,183 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TtemplateSet {
+type component templateSet_mycomp {};
+type set templateSet_myset {
+ integer f1,
+ float f2 };
+type record templateSet_rec {
+ templateSet_myset x1,
+ templateSet_myset x2,
+ templateSet_myset x3 optional };
+template templateSet_rec templateSet_tSpec :={ //specific values
+ x1:={f1:=1,f2:=1.2},
+ x2:={f1:=2,f2:=1.2},
+ x3:={f1:=3,f2:=1.2} };
+template templateSet_rec templateSet_tList :={ //specific value and value list
+ x1:={f2:=1.2,f1:=1},
+ x2:=({f1:=2,f2:=1.2},{f1:=3,f2:=1.2},{f1:=6,f2:=1.2}),
+ x3:={f1:=3,f2:=1.2} };
+template templateSet_rec templateSet_tComp :={ //specific value and compl. list
+ x1:={f1:=1,f2:=1.2},
+ x2:=complement ({f1:=2,f2:=1.2},{f1:=3,f2:=1.2},{f1:=6,f2:=1.2}),
+ x3:={f1:=3,f2:=1.2} };
+template templateSet_rec templateSet_tOmit :={ //omitting values
+ x1:={f1:=1,f2:=1.2},
+ x2:={f1:=2,f2:=1.2},
+ x3:=omit } ;
+template templateSet_rec templateSet_tAny :={ //specific and any value
+ x1:={f1:=1,f2:=1.2},
+ x2:={f1:=2,f2:=1.2},
+ x3:=? } ;
+template templateSet_rec templateSet_tAnyorNone :={ //specific and AnyorNone value
+ x1:={f1:=1,f2:=1.2},
+ x2:={f1:=2,f2:=1.2},
+ x3:=* };
+//template templateSet_rec templateSet_tIfpresent :={ //specific value and ifpresent
+// x1:={f1:=1,f2:=1.2},
+// x2:={f1:=2,f2:=1.2},
+// x3:={f1:=3,f2:=1.2} ifpresent };
+
+testcase templateSetSpec() runs on templateSet_mycomp {
+var templateSet_myset temp:={f1:=3,f2:=1.2};
+var templateSet_rec x1,x2; //specific value
+x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp };
+x2:={ x1:={f1:=2,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp };
+//match
+if (match(x1,templateSet_tSpec)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match
+if (not(match(x2,templateSet_tSpec))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetList() runs on templateSet_mycomp {
+var templateSet_myset temp:={f1:=3,f2:=1.2};
+var templateSet_rec x1,x2,x3; //value list
+x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=6,f2:=1.2}, x3:=temp };
+x2:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=7,f2:=1.2}, x3:=temp };
+x3:={ x1:={f1:=8,f2:=1.2}, x2:={f1:=6,f2:=1.2}, x3:=temp };
+//match
+if (match(x1,templateSet_tList)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of list
+if (not(match(x2,templateSet_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateSet_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetComp() runs on templateSet_mycomp {
+var templateSet_myset temp:={f1:=3,f2:=1.2};
+var templateSet_rec x1,x2,x3; //complemented list
+x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=7,f2:=1.2}, x3:=temp };
+x2:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=6,f2:=1.2}, x3:=temp };
+x3:={ x1:={f1:=2,f2:=1.2}, x2:={f1:=7,f2:=1.2}, x3:=temp };
+//match
+if (match(x1,templateSet_tComp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: in the list
+if (not(match(x2,templateSet_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateSet_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetOmit() runs on templateSet_mycomp {
+var templateSet_myset temp:={f1:=3,f2:=1.2};
+var templateSet_rec x1,x2,x3; //omitting value
+x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+x2:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp };
+x3:={ x1:={f1:=2,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+//match
+if (match(x1,templateSet_tOmit)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: not omitted
+if (not(match(x2,templateSet_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateSet_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetAny() runs on templateSet_mycomp {
+var templateSet_myset temp:={f1:=3,f2:=1.2};
+var templateSet_rec x1,x2,x3; //any value
+x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp };
+x2:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+x3:={ x1:={f1:=2,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp };
+//match
+if (match(x1,templateSet_tAny)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: field omitted
+if (not(match(x2,templateSet_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateSet_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetAnyorNone() runs on templateSet_mycomp {
+var templateSet_myset temp:={f1:=3,f2:=1.2};
+var templateSet_rec x1,x2,x3; //AnyorNone value
+x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+x2:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp };
+x3:={ x1:={f1:=2,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+//match: omitted
+if (match(x1,templateSet_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: value
+if (match(x2,templateSet_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateSet_tAnyorNone))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+//testcase templateSetIfpresent() runs on templateInt_mycomp {
+//var templateSet_myset temp1:={f1:=3,f2:=1.2}; //ifpresent
+//var templateSet_myset temp2:={f1:=4,f2:=1.2};
+//var templateSet_rec x1,x2,x3,x4;
+//x1:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp1 };
+//x2:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+//x3:={ x1:={f1:=1,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=temp2 };
+//x4:={ x1:={f1:=2,f2:=1.2}, x2:={f1:=2,f2:=1.2}, x3:=omit };
+//match: present and match
+//if (match(x1,templateSet_tIfpresent)) {setverdict(pass);}
+// else {setverdict(fail);}
+//match: not present
+//if (match(x2,templateSet_tIfpresent)) {setverdict(pass);}
+// else {setverdict(fail);}
+//no match: present and not match
+//if (not(match(x3,templateSet_tIfpresent))) {setverdict(pass);}
+// else {setverdict(fail);}
+//no match: other field
+//if (not(match(x4,templateSet_tIfpresent))) {setverdict(pass);}
+// else {setverdict(fail);}
+//}
+
+control {
+ execute(templateSetSpec());
+ execute(templateSetList());
+ execute(templateSetComp());
+ execute(templateSetOmit());
+ execute(templateSetAny());
+ execute(templateSetAnyorNone());
+// execute(templateSetIfpresent());
+
+}
+}
diff --git a/Regression_Test_java/src/TtemplateSetof.ttcn b/Regression_Test_java/src/TtemplateSetof.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..a63a1371129071cca5b24741e1d2e63fbf3d6223
--- /dev/null
+++ b/Regression_Test_java/src/TtemplateSetof.ttcn
@@ -0,0 +1,439 @@
+/******************************************************************************
+ * 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
+ * Koppany, Csaba
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TtemplateSetof {
+type component templateSetof_mycomp {};
+type set of integer templateSetof_mysetof;
+type record templateSetof_rec {
+ templateSetof_mysetof x1,
+ templateSetof_mysetof x2,
+ templateSetof_mysetof x3 optional };
+template templateSetof_rec templateSetof_tSpec :={ //specific values
+ x1:={1,1},
+ x2:={2,1},
+ x3:={3,1} };
+template templateSetof_rec templateSetof_tList :={ //specific value and value list
+ x1:={1,1},
+ x2:=({2,1},{3,1},{6,1}),
+ x3:={3,1} };
+template templateSetof_rec templateSetof_tComp :={ //specific value and compl. list
+ x1:={1,1},
+ x2:=complement ({2,1},{3,1},{6,1}),
+ x3:={3,1} };
+template templateSetof_rec templateSetof_tOmit :={ //omitting values
+ x1:={1,1},
+ x2:={2,1},
+ x3:=omit } ;
+template templateSetof_rec templateSetof_tAny :={ //specific and any value
+ x1:={1,1},
+ x2:={2,1},
+ x3:=? } ;
+template templateSetof_rec templateSetof_tAnyorNone :={ //specific and AnyorNone value
+ x1:={1,1},
+ x2:={2,1},
+ x3:=* };
+template templateSetof_rec templateSetof_tLength1 :={ //specific value and length (fix)
+ x1:={1,1},
+ x2:={2,1},
+ x3:=* length(3) };
+template templateSetof_rec templateSetof_tLength2 :={ //specific value and length (range)
+ x1:={1,1},
+ x2:={2,1},
+ x3:=? length(2..4) };
+template templateSetof_rec templateSetof_tLength3 :={ //specific value and length (range, infinity)
+ x1:={1,1},
+ x2:={2,1},
+ x3:=? length(2..infinity) };
+//template templateSetof_rec templateSetof_tSuperset :={ //specific value and superset
+// x1:={1,1},
+// x2:={2,1},
+// x3:=? superset (1,4) };
+//template templateSetof_rec templateSetof_tSubset :={ //specific value and subset
+// x1:={1,1},
+// x2:={2,1},
+// x3:=? subset (1,2,3,4) };
+template templateSetof_rec templateSetof_tIfpresent :={ //specific value and ifpresent
+ x1:={1,1},
+ x2:={2,1},
+ x3:={3,1} ifpresent };
+template templateSetof_rec templateSetof_tLengthIfp :={ //specific value and length (fix), ifpresent
+ x1:={1,1},
+ x2:={2,1},
+ x3:=? length(3) ifpresent};
+template templateSetof_rec templateSetof_tAnyEl :={ //specific value and any element inside value
+ x1:={1,1},
+ x2:={2,1},
+ x3:={3,?,1} } ;
+template templateSetof_rec templateSetof_tAnyorNoneEl :={ //specific value and Any number of elements or none inside value
+ x1:={1,1},
+ x2:={2,1},
+ x3:={3,*,1} };
+
+testcase templateSetofSpec() runs on templateSetof_mycomp {
+var templateSetof_mysetof temp:={3,1};
+var templateSetof_rec x1,x2,x3; //specific value
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp };
+x2:={ x1:={1,1}, x2:={1,2}, x3:=temp }; // other order
+x3:={ x1:={2,1}, x2:={2,1}, x3:=temp };
+//match
+if (match(x1,templateSetof_tSpec)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: other order
+if (match(x2,templateSetof_tSpec)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match
+if (not(match(x3,templateSetof_tSpec))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetofList() runs on templateSetof_mycomp {
+var templateSetof_mysetof temp:={3,1};
+var templateSetof_rec x1,x2,x3; //value list
+x1:={ x1:={1,1}, x2:={6,1}, x3:=temp };
+x2:={ x1:={1,1}, x2:={7,1}, x3:=temp };
+x3:={ x1:={8,1}, x2:={6,1}, x3:=temp };
+//match
+if (match(x1,templateSetof_tList)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of list
+if (not(match(x2,templateSetof_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateSetof_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetofComp() runs on templateSetof_mycomp {
+var templateSetof_mysetof temp:={3,1};
+var templateSetof_rec x1,x2,x3; //complemented list
+x1:={ x1:={1,1}, x2:={7,1}, x3:=temp };
+x2:={ x1:={1,1}, x2:={6,1}, x3:=temp };
+x3:={ x1:={2,1}, x2:={7,1}, x3:=temp };
+//match
+if (match(x1,templateSetof_tComp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: in the list
+if (not(match(x2,templateSetof_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateSetof_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetofOmit() runs on templateSetof_mycomp {
+var templateSetof_mysetof temp:={3,1};
+var templateSetof_rec x1,x2,x3; //omitting value
+x1:={ x1:={1,1}, x2:={2,1}, x3:=omit };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=temp };
+x3:={ x1:={2,1}, x2:={2,1}, x3:=omit };
+//match
+if (match(x1,templateSetof_tOmit)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: not omitted
+if (not(match(x2,templateSetof_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateSetof_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetofAny() runs on templateSetof_mycomp {
+var templateSetof_mysetof temp:={3,1};
+var templateSetof_rec x1,x2,x3; //any value
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=omit };
+x3:={ x1:={2,1}, x2:={2,1}, x3:=temp };
+//match
+if (match(x1,templateSetof_tAny)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: field omitted
+if (not(match(x2,templateSetof_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateSetof_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetofAnyorNone() runs on templateSetof_mycomp {
+var templateSetof_mysetof temp:={3,1};
+var templateSetof_rec x1,x2,x3; //AnyorNone value
+x1:={ x1:={1,1}, x2:={2,1}, x3:=omit };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=temp };
+x3:={ x1:={2,1}, x2:={2,1}, x3:=omit };
+//match: omitted
+if (match(x1,templateSetof_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: value
+if (match(x2,templateSetof_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateSetof_tAnyorNone))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetofLength1() runs on templateSetof_mycomp {
+var templateSetof_mysetof temp1:={1,2,3}; // length (fix)
+var templateSetof_mysetof temp2:={1,2};
+var templateSetof_rec x1,x2,x3,x4;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=omit };
+x3:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x4:={ x1:={1,1,1}, x2:={2,1}, x3:=temp1 };
+//match: proper size
+if (match(x1,templateSetof_tLength1)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: omitted
+if (match(x2,templateSetof_tLength1)) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: not proper length
+if (not(match(x3,templateSetof_tLength1))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x4,templateSetof_tLength1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetofLength2() runs on templateSetof_mycomp {
+var templateSetof_mysetof temp1:={1,2}; // length (range)
+var templateSetof_mysetof temp2:={1};
+var templateSetof_rec x1,x2,x3;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x3:={ x1:={1}, x2:={2,1}, x3:=temp1 };
+//match
+if (match(x1,templateSetof_tLength2)) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: not proper length
+if (not(match(x2,templateSetof_tLength2))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateSetof_tLength2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetofLength3() runs on templateSetof_mycomp {
+var templateSetof_mysetof temp1:={1,2}; // length (range, infinity)
+var templateSetof_mysetof temp2:={1};
+var templateSetof_rec x1,x2,x3;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x3:={ x1:={1}, x2:={2,1}, x3:=temp1 };
+//match
+if (match(x1,templateSetof_tLength3)) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: not proper length
+if (not(match(x2,templateSetof_tLength3))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateSetof_tLength3))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+//testcase templateSetofSuperset() runs on templateSetof_mycomp {
+//var templateSetof_mysetof temp1:={1,4}; // superset
+//var templateSetof_mysetof temp2:={2,1,4};
+//var templateSetof_mysetof temp3:={1};
+//var templateSetof_rec x1,x2,x3,x4;
+//x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+//x2:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+//x3:={ x1:={1,1}, x2:={2,1}, x3:=temp3 };
+//x4:={ x1:={1}, x2:={2,1}, x3:=temp1 };
+//match: equal
+//if (match(x1,templateSetof_tSuperset)) {setverdict(pass);}
+// else {setverdict(fail);}
+//match: real superset
+//if (match(x2,templateSetof_tSuperset)) {setverdict(pass);}
+// else {setverdict(fail);}
+//no match: not superset
+//if (not(match(x3,templateSetof_tSuperset))) {setverdict(pass);}
+// else {setverdict(fail);}
+//no match: other field
+//if (not(match(x4,templateSetof_tSuperset))) {setverdict(pass);}
+// else {setverdict(fail);}
+//}
+
+//testcase templateSetofSubset() runs on templateSetof_mycomp {
+//var templateSetof_mysetof temp1:={1,4,2,3}; // subset
+//var templateSetof_mysetof temp2:={1,4};
+//var templateSetof_mysetof temp3:={2,1,4,7};
+//var templateSetof_rec x1,x2,x3,x4;
+//x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+//x2:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+//x3:={ x1:={1,1}, x2:={2,1}, x3:=temp3 };
+//x4:={ x1:={2,1}, x2:={2,1}, x3:=temp1 };
+//match: equal
+//if (match(x1,templateSetof_tSubset)) {setverdict(pass);}
+// else {setverdict(fail);}
+//match: real subset
+//if (match(x2,templateSetof_tSubset)) {setverdict(pass);}
+// else {setverdict(fail);}
+//no match: not subset
+//if (not(match(x3,templateSetof_tSubset))) {setverdict(pass);}
+// else {setverdict(fail);}
+//no match: other field
+//if (not(match(x4,templateSetof_tSubset))) {setverdict(pass);}
+// else {setverdict(fail);}
+//}
+
+testcase templateSetofIfpresent() runs on templateSetof_mycomp {
+var templateSetof_mysetof temp1:={3,1}; //ifpresent
+var templateSetof_mysetof temp2:={4,1};
+var templateSetof_rec x1,x2,x3,x4;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=omit };
+x3:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x4:={ x1:={2,1}, x2:={2,1}, x3:=omit };
+// match: present and match
+if (match(x1,templateSetof_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+// match: not present
+if (match(x2,templateSetof_tIfpresent)) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: present and not match
+if (not(match(x3,templateSetof_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: other field
+if (not(match(x4,templateSetof_tIfpresent))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetofLengthIfp() runs on templateSetof_mycomp {
+var templateSetof_mysetof temp1:={1,2,3}; // length (fix), ifpresent
+var templateSetof_mysetof temp2:={1,2};
+var templateSetof_rec x1,x2,x3,x4;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=omit };
+x3:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x4:={ x1:={1,1,1}, x2:={2,1}, x3:=temp1 };
+// match: proper size
+if (match(x1,templateSetof_tLengthIfp)) {setverdict(pass);}
+ else {setverdict(fail);}
+// match: omitted
+if (match(x2,templateSetof_tLengthIfp)) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: not proper length
+if (not(match(x3,templateSetof_tLengthIfp))) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: other field
+if (not(match(x4,templateSetof_tLengthIfp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetofAnyEl() runs on templateSetof_mycomp {
+var templateSetof_mysetof temp1:={3,15,1}; // any element
+var templateSetof_mysetof temp2:={3,1};
+var templateSetof_mysetof temp3:={3,1,4,1};
+var templateSetof_mysetof temp4:={3,1,2};
+var templateSetof_rec x1,x2,x3,x4,x5;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x3:={ x1:={1,1}, x2:={2,1}, x3:=temp3 };
+x4:={ x1:={1,1}, x2:={2,1}, x3:=temp4 };
+x5:={ x1:={1}, x2:={2,1}, x3:=temp1 };
+// match
+if (match(x1,templateSetof_tAnyEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+// no match: no element
+if (not(match(x2,templateSetof_tAnyEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: two element
+if (not(match(x3,templateSetof_tAnyEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: wrong element
+if (match(x4,templateSetof_tAnyEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x5,templateSetof_tAnyEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateSetofAnyorNoneEl() runs on templateSetof_mycomp {
+var templateSetof_mysetof temp1:={3,1}; //Any number of elements or none
+var templateSetof_mysetof temp2:={3,2,1};
+var templateSetof_mysetof temp3:={3,5,2,1};
+var templateSetof_mysetof temp4:={4,2,1};
+var templateSetof_rec x1,x2,x3,x4,x5;
+x1:={ x1:={1,1}, x2:={2,1}, x3:=temp1 };
+x2:={ x1:={1,1}, x2:={2,1}, x3:=temp2 };
+x3:={ x1:={1,1}, x2:={2,1}, x3:=temp3 };
+x4:={ x1:={1,1}, x2:={2,1}, x3:=temp4 };
+x5:={ x1:={1}, x2:={2,1}, x3:=temp3 };
+//match: no element
+if (match(x1,templateSetof_tAnyorNoneEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: one element
+if (match(x2,templateSetof_tAnyorNoneEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: two element
+if (match(x3,templateSetof_tAnyorNoneEl)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other element
+if (not(match(x4,templateSetof_tAnyorNoneEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x5,templateSetof_tAnyorNoneEl))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+type set Block {}
+
+type set of Block Blocks;
+
+type set Request {
+ Blocks blocks optional
+}
+
+testcase HO91743() runs on templateSetof_mycomp {
+ var template Request vt_ReqO := { blocks := omit };
+ var template Request vt_ReqQ := { blocks := ? };
+ var template Request vt_ReqS := { blocks := * };
+ var template Block vt_b := {}
+
+ vt_ReqQ.blocks[3] := vt_b;
+ vt_ReqS.blocks[3] := vt_b;
+ // Indexing a template set-of which was omit used to DTE
+ // (in contrast to any-value and any-or-omit, which would create the set-of).
+ // HO91743 unifies the behaviour (set-of is created when indexing omit).
+ vt_ReqO.blocks[3] := vt_b;
+
+ if (lengthof(vt_ReqO.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
+ if (sizeof (vt_ReqO.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
+
+ if (lengthof(vt_ReqQ.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
+ if (sizeof (vt_ReqQ.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
+
+ if (lengthof(vt_ReqS.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
+ if (sizeof (vt_ReqS.blocks) == 4) { setverdict(pass); } else { setverdict(fail); }
+}
+
+control {
+ execute(templateSetofSpec());
+ execute(templateSetofList());
+ execute(templateSetofComp());
+ execute(templateSetofOmit());
+ execute(templateSetofAny());
+ execute(templateSetofAnyorNone());
+ execute(templateSetofLength1());
+ execute(templateSetofLength2());
+ execute(templateSetofLength3());
+// execute(templateSetofSuperset());
+// execute(templateSetofSubset());
+ execute(templateSetofIfpresent());
+ execute(templateSetofLengthIfp());
+ execute(templateSetofAnyEl());
+ execute(templateSetofAnyorNoneEl());
+ execute(HO91743());
+}
+}
diff --git a/Regression_Test_java/src/TtemplateUnion.ttcn b/Regression_Test_java/src/TtemplateUnion.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..84585cda197dcbe67b962091a8fcaf048b30a19d
--- /dev/null
+++ b/Regression_Test_java/src/TtemplateUnion.ttcn
@@ -0,0 +1,213 @@
+/******************************************************************************
+ * 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
+ * Delic, Adam
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TtemplateUnion {
+type component templateUnion_mycomp {};
+type union templateUnion_myunion {
+ integer f1,
+ float f2 };
+type record templateUnion_rec {
+ templateUnion_myunion x1,
+ templateUnion_myunion x2,
+ templateUnion_myunion x3 optional };
+template templateUnion_rec templateUnion_tSpec :={ //specific values
+ x1:={f2:=1.2},
+ x2:={f1:=2},
+ x3:={f1:=3} };
+template templateUnion_rec templateUnion_tList :={ //specific value and value list
+ x1:={f2:=1.2},
+ x2:=({f1:=2},{f1:=3},{f2:=1.2}),
+ x3:={f1:=3} };
+template templateUnion_rec templateUnion_tComp :={ //specific value and compl. list
+ x1:={f2:=1.2},
+ x2:=complement ({f1:=2},{f2:=1.2},{f1:=6}),
+ x3:={f1:=3} };
+template templateUnion_rec templateUnion_tOmit :={ //omitting values
+ x1:={f2:=1.2},
+ x2:={f1:=2},
+ x3:=omit } ;
+template templateUnion_rec templateUnion_tAny :={ //specific and any value
+ x1:={f2:=1.2},
+ x2:={f1:=2},
+ x3:=? } ;
+template templateUnion_rec templateUnion_tAnyorNone :={ //specific and AnyorNone value
+ x1:={f2:=1.2},
+ x2:={f1:=2},
+ x3:=* };
+//template templateUnion_rec templateUnion_tIfpresent :={ //specific value and ifpresent
+// x1:={f2:=1.2},
+// x2:={f1:=2},
+// x3:={f1:=3} ifpresent };
+
+testcase templateUnionSpec() runs on templateUnion_mycomp {
+var templateUnion_myunion temp:={f1:=3};
+var templateUnion_rec x1,x2; //specific value
+x1:={ x1:={f2:=1.2}, x2:={f1:=2}, x3:=temp };
+x2:={ x1:={f2:=1.3}, x2:={f1:=2}, x3:=temp };
+//match
+if (match(x1,templateUnion_tSpec)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match
+if (not(match(x2,templateUnion_tSpec))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateUnionList() runs on templateUnion_mycomp {
+var templateUnion_myunion temp:={f1:=3};
+var templateUnion_rec x1,x2,x3; //value list
+x1:={ x1:={f2:=1.2}, x2:={f1:=3}, x3:=temp };
+x2:={ x1:={f2:=1.2}, x2:={f1:=7}, x3:=temp };
+x3:={ x1:={f1:=8}, x2:={f1:=3}, x3:=temp };
+//match
+if (match(x1,templateUnion_tList)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: out of list
+if (not(match(x2,templateUnion_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateUnion_tList))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateUnionComp() runs on templateUnion_mycomp {
+var templateUnion_myunion temp:={f1:=3};
+var templateUnion_rec x1,x2,x3; //complemented list
+x1:={ x1:={f2:=1.2}, x2:={f1:=7}, x3:=temp };
+x2:={ x1:={f2:=1.2}, x2:={f1:=6}, x3:=temp };
+x3:={ x1:={f2:=1.3}, x2:={f1:=7}, x3:=temp };
+//match
+if (match(x1,templateUnion_tComp)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: in the list
+if (not(match(x2,templateUnion_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateUnion_tComp))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateUnionOmit() runs on templateUnion_mycomp {
+var templateUnion_myunion temp:={f1:=3};
+var templateUnion_rec x1,x2,x3; //omitting value
+x1:={ x1:={f2:=1.2}, x2:={f1:=2}, x3:=omit };
+x2:={ x1:={f2:=1.2}, x2:={f1:=2}, x3:=temp };
+x3:={ x1:={f1:=2}, x2:={f1:=2}, x3:=omit };
+//match
+if (match(x1,templateUnion_tOmit)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: not omitted
+if (not(match(x2,templateUnion_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateUnion_tOmit))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateUnionAny() runs on templateUnion_mycomp {
+var templateUnion_myunion temp:={f1:=3};
+var templateUnion_rec x1,x2,x3; //any value
+x1:={ x1:={f2:=1.2}, x2:={f1:=2}, x3:=temp };
+x2:={ x1:={f2:=1.2}, x2:={f1:=2}, x3:=omit };
+x3:={ x1:={f1:=2}, x2:={f1:=2}, x3:=temp };
+//match
+if (match(x1,templateUnion_tAny)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: field omitted
+if (not(match(x2,templateUnion_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateUnion_tAny))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase templateUnionAnyorNone() runs on templateUnion_mycomp {
+var templateUnion_myunion temp:={f1:=3};
+var templateUnion_rec x1,x2,x3; //AnyorNone value
+x1:={ x1:={f2:=1.2}, x2:={f1:=2}, x3:=omit };
+x2:={ x1:={f2:=1.2}, x2:={f1:=2}, x3:=temp };
+x3:={ x1:={f1:=2}, x2:={f1:=2}, x3:=omit };
+//match: omitted
+if (match(x1,templateUnion_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//match: value
+if (match(x2,templateUnion_tAnyorNone)) {setverdict(pass);}
+ else {setverdict(fail);}
+//no match: other field
+if (not(match(x3,templateUnion_tAnyorNone))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+//testcase templateUnionIfpresent() runs on templateInt_mycomp {
+//var templateUnion_myunion temp1:={f1:=3}; //ifpresent
+//var templateUnion_myunion temp2:={f1:=4};
+//var templateUnion_rec x1,x2,x3,x4;
+//x1:={ x1:={f2:=1.2}, x2:={f1:=2}, x3:=temp1 };
+//x2:={ x1:={f2:=1.2}, x2:={f1:=2}, x3:=omit };
+//x3:={ x1:={f2:=1.2}, x2:={f1:=2}, x3:=temp2 };
+//x4:={ x1:={f2:=1.4}, x2:={f1:=2}, x3:=omit };
+//match: present and match
+//if (match(x1,templateUnion_tIfpresent)) {setverdict(pass);}
+// else {setverdict(fail);}
+//match: not present
+//if (match(x2,templateUnion_tIfpresent)) {setverdict(pass);}
+// else {setverdict(fail);}
+//no match: present and not match
+//if (not(match(x3,templateUnion_tIfpresent))) {setverdict(pass);}
+// else {setverdict(fail);}
+//no match: other field
+//if (not(match(x4,templateUnion_tIfpresent))) {setverdict(pass);}
+// else {setverdict(fail);}
+//}
+
+type record MyRec2{
+ ROC roc optional,
+ ROI roi optional,
+ MyUnion1 u optional,
+ MyRecord1 r optional
+}
+
+type record of charstring ROC;
+type record of integer ROI;
+type record MyRecord1 {
+ integer i optional,
+ float x optional,
+ charstring c
+}
+
+type union MyUnion1 {
+ ROC roc,
+ integer i,
+ ROI roi,
+ MyRecord1 r
+}
+
+testcase tc_record_withWildCard3E() runs on templateUnion_mycomp {
+ var template MyRec2 vtl_rec2;
+ vtl_rec2:={ u := ? }
+ //log("The value of the record:",vtl_rec2.u);
+ if(ispresent(vtl_rec2.u.i)){setverdict(fail)}else {setverdict(pass)};
+}
+
+control {
+ execute(templateUnionSpec());
+ execute(templateUnionList());
+ execute(templateUnionComp());
+ execute(templateUnionOmit());
+ execute(templateUnionAny());
+ execute(templateUnionAnyorNone());
+// execute(templateUnionIfpresent());
+ execute(tc_record_withWildCard3E());
+}
+}
diff --git a/Regression_Test_java/src/TucharstrOper.ttcn b/Regression_Test_java/src/TucharstrOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..544d26cfca616cc0e3939fa86d5579487a2d649e
--- /dev/null
+++ b/Regression_Test_java/src/TucharstrOper.ttcn
@@ -0,0 +1,111 @@
+/******************************************************************************
+ * 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
+ * Szabados, Kristof
+ *
+ ******************************************************************************/
+module TucharstrOper
+{
+type component ucharstrOper_comptype { }
+
+type universal charstring myustr0
+type myustr0 myustr1
+type myustr0 myustr2 (char(0, 0, 0, 1)..char(0, 0, 1, 0))
+type myustr0 myustr3 (char(0, 0, 0, 0), char(0, 0, 0, 1), char(0, 0, 1, 0))
+type myustr0 myustr4 (char(0, 0, 0, 0) & char(0, 0, 0, 0), c_myustr0)
+type myustr0 myustr5 (c_myustr0..c_myustr0) length(lengthof(c_myustr0))
+type universal charstring myustr6 (pattern "abc?\q{0, 0, 0, 65}")
+type myustr0 myustr7 (pattern "abc*xyz")
+type myustr7 myustr8 length(0) // It should be an empty set.
+type myustr1 myustr9 length(2)
+type universal charstring MyUCharString1 ("a".."z")
+type universal charstring MyUCharString2 (char(0, 0, 1, 111)..char(0, 0, 1, 113))
+type universal charstring myustr10 (myustr2, myustr3)
+type universal charstring myustr11 length(0..infinity) // Full set.
+
+const myustr0 c_myustr0 := char(0, 0, 0, 0)
+const myustr7 c_myustr1 := "abcxyz"
+const myustr10 c_myustr2 := char(0, 0, 0, 1)
+
+template myustr0 t_myustr0 := char(0, 0, 0, 0)
+template myustr7 t_myustr1 := "abc" & c_myustr1 & "xyz"
+template myustr3 t_myustr2 := pattern char(0, 0, 0, 1)
+template myustr10 t_myustr3 := c_myustr2
+template myustr2 t_myustr4 := char(0, 0, 0, 1) length(1)
+
+function f_ustr1() return myustr7 {
+ if (lengthof(t_myustr1) > lengthof(c_myustr1)) { return valueof(t_myustr1) }
+ else { return c_myustr1 }
+}
+
+testcase ucharstrSubtypes() runs on ucharstrOper_comptype {
+ var template myustr2 vt_myustr1 := char(0, 0, 0, 1) // Value range.
+ var template myustr3 vt_myustr2 := vt_myustr1 // Value list.
+ var template myustr5 vt_myustr3 := char(0, 0, 0, 0) // Length and value range.
+ var template myustr9 vt_myustr4 := valueof(vt_myustr3) & valueof(vt_myustr3) // Length only.
+ var myustr2 v_myustr1 := char(0, 0, 0, 1)
+ var myustr3 v_myustr2 := v_myustr1
+ var myustr5 v_myustr3 := char(0, 0, 0, 0)
+ var myustr9 v_myustr4 := v_myustr3 & v_myustr3
+
+ if (valueof(vt_myustr1) == v_myustr1 and v_myustr2 == valueof(vt_myustr2)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (valueof(vt_myustr3) == v_myustr3 and v_myustr4 == valueof(vt_myustr4)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (f_ustr1() == "abc" & c_myustr1 & "xyz") { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+testcase ucharstrIsvalue() runs on ucharstrOper_comptype {
+ var universal charstring us := "foo";
+ var universal charstring un;
+ var template universal charstring ust := "bar";
+
+ if ( isvalue(us) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(un) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(ust) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+testcase ucharstrIsbound() runs on ucharstrOper_comptype {
+ var universal charstring us := "foo";
+ var universal charstring un;
+ var template universal charstring ust := "bar";
+
+ if ( isbound(un) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(un[0]) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(us) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(ust) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+testcase CR_TR00018474() runs on ucharstrOper_comptype {
+ // Indexing of string template variables.
+ var template universal charstring vtu1 := "fisherman"
+ var template universal charstring vtu2 := char(0, 0, 0, 65) & "F" & char(0, 0, 0, 65)
+ vtu1[0] := "F"
+ if (match(char(0, 0, 0, 70) & char(0, 0, 0, 105) & char(0, 0, 0, 115) & char(0, 0, 0, 104) & char(0, 0, 0, 101) & char(0, 0, 0, 114) & char(0, 0, 0, 109) & char(0, 0, 0, 97) & char(0, 0, 0, 110), vtu1)) { setverdict(pass) } else { setverdict(fail) }
+ vtu1[0] := "F" // Indexed assignment notation cannot be used here.
+ vtu1[1] := "i" // Still works, nothing special.
+ if (match(char(0, 0, 0, 70) & char(0, 0, 0, 105) & char(0, 0, 0, 115) & char(0, 0, 0, 104) & char(0, 0, 0, 101) & char(0, 0, 0, 114) & char(0, 0, 0, 109) & char(0, 0, 0, 97) & char(0, 0, 0, 110), vtu1)) { setverdict(pass) } else { setverdict(fail) }
+ vtu2[0] := "B"
+ if (match("BF" & char(0, 0, 0, 65), vtu2)) { setverdict(pass) } else { setverdict(fail) }
+}
+
+control {
+ const universal charstring cl_1 := char(0, 0, 0, 0)
+ const universal charstring cl_2 := "abcxyz"
+ var universal charstring vl_1 := char(0, 0, 0, 0)
+ var universal charstring vl_2 := "abcxyz"
+
+ execute(ucharstrSubtypes());
+ execute(ucharstrIsvalue());
+ execute(ucharstrIsbound());
+ execute(CR_TR00018474());
+}
+}
diff --git a/Regression_Test_java/src/TunionOper.ttcn b/Regression_Test_java/src/TunionOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..89752f69dda949d44f473d6797910c5159a49a01
--- /dev/null
+++ b/Regression_Test_java/src/TunionOper.ttcn
@@ -0,0 +1,1168 @@
+/******************************************************************************
+ * 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
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TunionOper {
+// ********** Type definitions *********************
+type component unionOper_mycomp {};
+type enumerated unionOper_myenum {xx1,xx2,xx3};
+type record unionOper_trecord {
+ integer x1 optional,
+ float x2 };
+type record of octetstring unionOper_trecof;
+type set unionOper_tset {
+ integer x1,
+ float x2 optional };
+type set of charstring unionOper_tsetof;
+type union unionOper_tunion {
+ integer x1,
+ float x2 };
+type union unionOper_myunion1 {integer x1, float x2}; // union of basic types
+type union unionOper_myunion2 { // union of enum
+ unionOper_myenum x1,
+ integer x2};
+type union unionOper_myunion3 { // union of record
+ unionOper_trecord x1,
+ integer x2};
+type union unionOper_myunion4 { // union of record of
+ unionOper_trecof x1,
+ integer x2};
+type union unionOper_myunion5 { // union of set
+ unionOper_tset x1,
+ integer x2};
+type union unionOper_myunion6 { // union of set of
+ unionOper_tsetof x1,
+ integer x2};
+type union unionOper_myunion7 { // union of union
+ unionOper_tunion x1,
+ integer x2};
+type union unionOper_myunion8 { // union of same types
+ integer x1,
+ integer x2};
+ type union typedefunionComp_myunion {
+ unionOper_trecord x1,
+ unionOper_trecof x2,
+ unionOper_tset x3,
+ unionOper_tsetof x4,
+ unionOper_tunion x5,
+ integer x6[3]
+ };
+// *************** Constanst ***********************
+//const unionOper_trecord unionOper_temp1:={ x1:=omit, x2:=3.4 };
+//const unionOper_trecof unionOper_temp2:={ 'AF12'O };
+//const unionOper_tset unionOper_temp3:={ x1:=234, x2:=1.9};
+//const unionOper_tsetof unionOper_temp4:={"f","8"};
+//const unionOper_tunion unionOper_temp5:={ x2:=1.3 };
+const unionOper_myunion1 unionOper_const1:={ //union with basic types
+ x1:=1 };
+const unionOper_myunion2 unionOper_const2:={ //union with enum
+ x1:=xx1 };
+const unionOper_myunion3 unionOper_const4:={ //union from record
+ x1:={ x1:=1, x2:=1.2 } };
+const unionOper_myunion4 unionOper_const6:={ //union from record of
+ x1:={ '12AB'O, 'CD12'O } };
+const unionOper_myunion5 unionOper_const8:={ //union from set
+ x1:={ x1:=2, x2:=1.3} };
+const unionOper_myunion6 unionOper_const10:={ //union from set of
+ x1:={"a","b"} };
+const unionOper_myunion7 unionOper_const12:={ //union from union
+ x1:={ x1 :=3 } };
+const typedefunionComp_myunion unionOper_const13:= { x1:={ x1:=1, x2:=1.2 }};
+const typedefunionComp_myunion unionOper_const14:= { x2:={ '12AB'O, 'CD12'O }};
+const typedefunionComp_myunion unionOper_const15:= { x3:={ x1:=2, x2:=1.3 }};
+const typedefunionComp_myunion unionOper_const16:= { x4:={ "a", "b", "c" }};
+const typedefunionComp_myunion unionOper_const17:= { x5:={ x1 :=3 }};
+const typedefunionComp_myunion unionOper_const18:= { x6:={ 1,2,3}};
+
+testcase unionAssign() runs on unionOper_mycomp{
+var unionOper_myunion1 x1:={ //union with basic types
+ x1:=1};
+var unionOper_myunion1 x2,x3;
+x2:={ x2:=1.2 };
+if (x1.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==1.2) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (ischosen(x2.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionAssignEnum() runs on unionOper_mycomp{
+var unionOper_myunion2 x1:={ //union with enum
+ x1:=xx1};
+var unionOper_myunion2 x2;
+x2:={ x1:=xx2 };
+if (x1.x1==xx1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1==xx2) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionAssignRec() runs on unionOper_mycomp{
+//var unionOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var unionOper_myunion3 x1:={ //union from record
+ x1:={ x1:=1, x2:=1.2 } };
+var unionOper_myunion3 x2;
+x2:={ x1:={ x1:=1, x2:=1.2 } };
+if (x1.x1.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionAssignRecof() runs on unionOper_mycomp{
+//var unionOper_trecof temp2:={'AF12'O};
+var unionOper_myunion4 x1:={ //union from record of
+ x1:={ '12AB'O, 'CD12'O } };
+var unionOper_myunion4 x2;
+x2:={ x1:={ '12AB'O, 'CD12'O } };
+if (x1.x1[0]=='12AB'O) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1[0]=='12AB'O) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase unionAssignSet() runs on unionOper_mycomp{
+//var unionOper_tset temp1:={ x1:=2, x2:=omit };
+var unionOper_myunion5 x1:={ //union from record
+ x1:={ x1:=1, x2:=1.2 } };
+var unionOper_myunion5 x2;
+x2:={ x1:={ x1:=1, x2:=1.2 } };
+if (x1.x1.x1==1) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x1==1) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionAssignSetof() runs on unionOper_mycomp{
+//var unionOper_tsetof temp2:={"a","7"};
+var unionOper_myunion6 x1:={ //union from set of
+ x1:={ "1", "a" } };
+var unionOper_myunion6 x2;
+x2:={ x1:={ "1", "a" } };
+if (x1.x1[0]=="1") {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (x1.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1[0]=="1") {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (x2.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionAssignUnion() runs on unionOper_mycomp{
+var unionOper_tunion temp5 := {x2:=1.3}
+var unionOper_myunion7 x1:={ //union from union
+ x1:={ x1 :=3 } };
+var unionOper_myunion7 x2;
+x2:={ x1:={ x1 :=3 } };
+if (x1.x1.x1==3) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+if (ischosen(x1.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x1==3) {setverdict(pass);} //later
+ else {setverdict(fail);}
+if (ischosen(x2.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionAssignElem() runs on unionOper_mycomp{
+var unionOper_myunion1 x1, x2; //union with basic types
+x1:={ x1:=1 };
+x2:= {x1:=2}
+x1.x1:=3; // change value
+x2.x2:=3.2; //choose other
+if (x1.x1==3) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==3.2) {setverdict(pass);} //choose other
+ else {setverdict(fail);}
+if (ischosen(x2.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionAssignElemEnum() runs on unionOper_mycomp{
+var unionOper_myunion2 x1, x2; //union with enum
+x1:={ x1:=xx1 };
+x2:= {x1:=xx2}
+x1.x1:=xx3; // change value
+x2.x2:=3; //choose other
+if (x1.x1==xx3) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==3) {setverdict(pass);} //choose other
+ else {setverdict(fail);}
+if (ischosen(x2.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionAssignElemRec() runs on unionOper_mycomp{
+//var unionOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var unionOper_myunion3 x1,x2; //union from record
+x1:={ x1:={ x1:=1, x2:=1.2 } };
+x2:={ x1:={ x1:=1, x2:=1.2 } };
+x1.x1.x1:=2; //change value
+x2.x2:=2; //change selection
+if (x1.x1.x1==2) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (x1.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==2) {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (ischosen(x2.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionAssignElemRecof() runs on unionOper_mycomp{
+//var unionOper_trecof temp2:={'AF12'O};
+var unionOper_myunion4 x1,x2; //union from record of
+x1:={ x1:={ '12AB'O, 'CD12'O } };
+x2:={ x1:={ '12AB'O, 'CD12'O } };
+x1.x1[1]:='34AB'O; //change value
+x2.x2:=2; //change selection
+if (x1.x1[0]=='12AB'O) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (x1.x1[1]=='34AB'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==2) {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (ischosen(x2.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase unionAssignElemSet() runs on unionOper_mycomp{
+//var unionOper_tset temp1:={ x1:=2, x2:=omit };
+var unionOper_myunion5 x1,x2; //union from record
+x1:= { x1:={ x1:=1, x2:=1.2 } };
+x2:= { x1:={ x1:=1, x2:=1.2 } };
+x1.x1.x2:=3.4; //change value
+x2.x2:=3; //change selection
+if (x1.x1.x1==1) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (x1.x1.x2==3.4) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x2==3) {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (ischosen(x2.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionAssignElemSetof() runs on unionOper_mycomp{
+//var unionOper_tsetof temp2:={"a","7"};
+var unionOper_myunion6 x1,x2; //union from record of
+x1:={ x1:={ "1", "a" } };
+x2:={ x2:=1 };
+x1.x1[0]:="h"; //change value
+x2.x1:={ "1", "a" }; //change selection
+if (x1.x1[0]=="h") {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (x1.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1[0]=="1") {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (x2.x1[1]=="a") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionAssignElemUnion() runs on unionOper_mycomp{
+//var unionOper_tunion temp5 := {x2:=1.3}
+var unionOper_myunion7 x1,x2; //union from union
+x1:={ x1:={ x1 :=3 } };
+x2:={ x2:=2 };
+x1.x1.x2:=3.4; //change value
+x2.x1:={ x2 :=3.4 }; //change selection
+if (x1.x1.x2==3.4) {setverdict(pass);} //change value
+ else {setverdict(fail);}
+if (ischosen(x1.x1.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x1.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x2.x1.x2==3.4) {setverdict(pass);} //change selection
+ else {setverdict(fail);}
+if (ischosen(x2.x1.x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x1.x1))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(x2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(x2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase unionConst() runs on unionOper_mycomp{
+const unionOper_myunion1 const1:={ //union with basic types
+ x1:=1 };
+if (unionOper_const1.x1==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (ischosen(unionOper_const1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(unionOper_const1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const1.x1==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (ischosen(const1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionConstEnum() runs on unionOper_mycomp{
+const unionOper_myunion2 const2:={ //union with enum
+ x1:=xx1 };
+if (unionOper_const2.x1==xx1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (ischosen(unionOper_const2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(unionOper_const2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const2.x1==xx1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (ischosen(const2.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const2.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionConstRec() runs on unionOper_mycomp{
+const unionOper_myunion3 const4:={ //union from record
+ x1:={ x1:=1, x2:=1.2 } };
+if (unionOper_const4.x1.x1==1) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (unionOper_const4.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(unionOper_const4.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(unionOper_const4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const4.x1.x1==1) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const4.x1.x2==1.2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const4.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const4.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionConstRecof() runs on unionOper_mycomp{
+const unionOper_myunion4 const6:={ //union from record of
+ x1:={ '12AB'O, 'CD12'O } };
+if (unionOper_const6.x1[0]=='12AB'O) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (unionOper_const6.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(unionOper_const6.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(unionOper_const6.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const6.x1[0]=='12AB'O) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const6.x1[1]=='CD12'O) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const6.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const6.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+testcase unionConstSet() runs on unionOper_mycomp{
+const unionOper_myunion5 const8:={ //union from set
+ x1:={ x1:=2, x2:=1.3} };
+if (unionOper_const8.x1.x1==2) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (unionOper_const8.x1.x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(unionOper_const8.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(unionOper_const8.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const8.x1.x1==2) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const8.x1.x2==1.3) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const8.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const8.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionConstSetof() runs on unionOper_mycomp{
+const unionOper_myunion6 const10:={ //union from set of
+ x1:={"a","b"} };
+if (unionOper_const10.x1[0]=="a") {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (unionOper_const10.x1[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(unionOper_const10.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(unionOper_const10.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const10.x1[0]=="a") {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (const10.x1[1]=="b") {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const10.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const10.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionConstUnion() runs on unionOper_mycomp{
+const unionOper_myunion7 const12:={ //union from union
+ x1:={ x1 :=3 } };
+if (unionOper_const12.x1.x1==3) {setverdict(pass);} //definition part
+ else {setverdict(fail);}
+if (ischosen(unionOper_const12.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(unionOper_const12.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(unionOper_const12.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(unionOper_const12.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (const12.x1.x1==3) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+if (ischosen(const12.x1.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const12.x1.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+if (ischosen(const12.x1)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(ischosen(const12.x2))) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionComp() runs on unionOper_mycomp{
+var unionOper_myunion1 x1,x2,x3,x4;
+x1:={ x1:=1 };
+x2:={ x1:=1 };
+x3:={ x1:=2 }; // different value
+x4:={ x2:=1.2 }; // different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+testcase unionCompSame() runs on unionOper_mycomp{
+var unionOper_myunion8 x1,x2;
+x1:={ x1:=1 }; // same value, different selection
+x2:={ x2:=1 };
+if (x1!=x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+testcase unionCompEnum() runs on unionOper_mycomp{
+var unionOper_myunion2 x1,x2,x3,x4;
+x1:={ x1:=xx1 };
+x2:={ x1:=xx1 };
+x3:={ x1:=xx2 }; // different value
+x4:={ x2:=1 }; // different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+
+testcase unionCompRec() runs on unionOper_mycomp{
+//var unionOper_trecord temp1:={ x1:=omit, x2:=3.4 };
+var unionOper_myunion3 x1,x2,x3,x4;
+x1 :={ x1:={ x1:=1, x2:=1.2 } };
+x2 :={ x1:={ x1:=1, x2:=1.2 } };
+x3 :={ x1:={ x1:=2, x2:=1.2 } }; // different value
+x4 :={ x2:=1 }; // different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+
+testcase unionCompRecof() runs on unionOper_mycomp{
+//var unionOper_trecof temp2:={'AF12'O};
+var unionOper_myunion4 x1,x2,x3,x4; //union from record of
+x1:={ x1:={ '12AB'O, 'CD12'O } };
+x2:={ x1:={ '12AB'O, 'CD12'O } };
+x3:={ x1:={ '12AB'O } }; //different value
+x4:={ x2:=12 }; //different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+
+testcase unionCompSet() runs on unionOper_mycomp{
+//var unionOper_tset temp1:={ x1:=2, x2:=omit };
+var unionOper_myunion5 x1,x2,x3,x4; // union from set
+x1:={ x1:={ x1:=1, x2:=1.2 } };
+x2:={ x1:={ x1:=1, x2:=1.2 } };
+x3:={ x1:={ x1:=4, x2:=1.2 } }; // different value
+x4:={ x2:=4 }; // different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+testcase unionCompSetof() runs on unionOper_mycomp{
+//var unionOper_tsetof temp2:={"a","7"};
+var unionOper_myunion6 x1,x2,x3,x4; //union from record of
+x1:={ x1:={ "1", "a" } };
+x2:={ x1:={ "1", "a" } };
+x3:={ x1:={ "1", "a", "k" } }; //different value
+x4:={ x2:=2 }; //different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+testcase unionCompUnion() runs on unionOper_mycomp{
+var unionOper_tunion temp5 := {x2:=1.3}
+var unionOper_myunion7 x1,x2,x3,x4; // union form union
+x1:={ x1:={ x1 :=3 } };
+x2:={ x1:={ x1 :=3 } };
+x3:={ x1:={ x2 :=3.9 } }; //different value
+x4:={ x2:=3 }; //different selection
+if (x1==x2) {setverdict(pass);}
+ else {setverdict(fail);}
+if (not(x1==x3)) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (not(x4==x1)) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+if (not(x1!=x2)) {setverdict(pass);}
+ else {setverdict(fail);}
+if (x1!=x3) {setverdict(pass);} // different value
+ else {setverdict(fail);}
+if (x4!=x2) {setverdict(pass);} // different selection
+ else {setverdict(fail);}
+}
+
+type union myu1 {
+ integer f1 (0..255),
+ charstring f2 length(0..255)
+}
+type myu1 myu2
+type myu1 myu3 ({ f1 := 0 }, { f1 := 1 }, { f2 := "" })
+type myu1 myu4 (myu3)
+
+function f_u1() return myu3 {
+ var myu1 v_myu1 := { f1 := 0 }
+ var myu2 v_myu2 := { f2 := "" }
+ if (v_myu1 == v_myu2) { return v_myu1 }
+ else { return v_myu2 }
+}
+
+testcase unionSubtypes() runs on unionOper_mycomp {
+ var template myu1 vt_myu1 := { f1 := 0 } // Restricted fields.
+ var template myu4 vt_myu2 := { f2 := "" } // Type list.
+ var myu1 v_myu1 := { f2 := "0" }
+ var myu4 v_myu2 := { f2 := "" }
+
+ if (valueof(vt_myu1.f1) == str2int(v_myu1.f2) and v_myu2 == valueof(vt_myu2)) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (f_u1() != f_u1()) { setverdict(fail) }
+ else { setverdict(pass) }
+}
+
+testcase unionIsvalue() runs on unionOper_mycomp{
+ var unionOper_tunion u0;
+ var unionOper_tunion u1 := { x1 := 1 };
+ var unionOper_tunion u2;
+ u2.x2 := 1.0;
+ var unionOper_tunion u3 := { x2 := 1.0 };
+ if ( isvalue(u0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(u1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(u2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(u3) ) { setverdict(pass); } else { setverdict(fail); };
+
+ template unionOper_tunion t_union1 := { x1:= 1 }
+ template unionOper_tunion t_union2 := * ;
+ template unionOper_tunion t_union3 := { x1 := (1,2,3) }
+ template unionOper_tunion t_union4 := { x1 := ? }
+
+ if ( isvalue(t_union1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(t_union1.x1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(t_union2) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(t_union3) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(t_union3.x1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(t_union4) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(t_union4.x1) ) { setverdict(fail); } else { setverdict(pass); };
+
+ if ( isvalue(modifies t_union1 := { x2 := 33.0 }) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isvalue(modifies t_union1 := { x2 := ? }) ) { setverdict(fail); } else { setverdict(pass); };
+}
+
+testcase unionIsbound() runs on unionOper_mycomp{
+ var unionOper_tunion u0;
+ var unionOper_tunion u1 := { x1 := 1 };
+ var unionOper_tunion u2;
+ u2.x2 := 1.0;
+ var unionOper_tunion u3 := { x2 := 1.0 };
+ if ( isbound(u0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(u0.x1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(u0.x2) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(u1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(u1.x1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(u1.x2) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(u2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(u2.x1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(u2.x2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(u3) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(u3.x1) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isbound(u3.x2) ) { setverdict(pass); } else { setverdict(fail); };
+
+ template unionOper_tunion t_union1 := { x1:= 1 }
+ template unionOper_tunion t_union2 := * ;
+ template unionOper_tunion t_union3 := { x1 := (1,2,3) }
+ template unionOper_tunion t_union4 := { x1 := ? }
+
+ if ( isbound(t_union1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(t_union1.x1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(t_union2) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(t_union3) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(t_union3.x1) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(t_union4) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(t_union4.x1) ) { setverdict(pass); } else { setverdict(fail); };
+
+ if ( isbound(modifies t_union1 := { x2 := 33.0 }) ) { setverdict(pass); } else { setverdict(fail); };
+ if ( isbound(modifies t_union1 := { x2 := ? }) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+type record of charstring ROC;
+type record of integer ROI;
+type record MyRecord1 {
+ integer i optional,
+ float x optional,
+ charstring c
+}
+
+type union MyUnion1 {
+ ROC roc,
+ integer i,
+ ROI roi,
+ MyRecord1 r
+}
+
+const MyUnion1 c_myunion1:= { roc:= { "1aa", "2bb", "3cc"}}
+const MyUnion1 c_myunion2:= { i:= 5}
+
+testcase tc_unionOfRecordOfs1() runs on unionOper_mycomp {
+ var MyUnion1 vl_u:= c_myunion1;
+ if(isbound(vl_u)) {setverdict(pass)} else {setverdict(fail)}
+ if(isbound(vl_u.roc)){setverdict(pass)} else {setverdict(fail)}
+ if(isbound(vl_u.roc[0])){setverdict(pass)}else {setverdict(fail)}
+ if(isbound(vl_u.roc[1])){setverdict(pass)}else {setverdict(fail)}
+ if(isbound(vl_u.roc[2])){setverdict(pass)}else {setverdict(fail)}
+ if(isbound(vl_u.roc[3])){setverdict(fail)}else {setverdict(pass)}
+ if(isbound(vl_u.roc[99])){setverdict(fail)}else {setverdict(pass)}
+ if(isbound(vl_u.i)){setverdict(fail)}else {setverdict(pass)}
+ if(isbound(vl_u.roi)){setverdict(fail)}else {setverdict(pass)}
+ if(isbound(vl_u.roi[0])){setverdict(fail)}else {setverdict(pass)}
+ if(isbound(vl_u.roi[1])){setverdict(fail)} else {setverdict(pass)}
+ log(vl_u.roc);
+}
+
+testcase tc_unionOfRecordOfs2() runs on unionOper_mycomp {
+ var MyUnion1 vl_u:= c_myunion2;
+ if(isbound(vl_u)) {setverdict(pass)} else {setverdict(fail)}
+ if(isbound(vl_u.roc)){setverdict(fail)} else {setverdict(pass)}
+ if(isbound(vl_u.roc[0])){setverdict(fail)} else {setverdict(pass)}
+ if(isbound(vl_u.roc[1])){setverdict(fail)} else {setverdict(pass)}
+ if(isbound(vl_u.roc[2])){setverdict(fail)} else {setverdict(pass)}
+ if(isbound(vl_u.roc[3])){setverdict(fail)} else {setverdict(pass)}
+ if(isbound(vl_u.roc[99])){setverdict(fail)} else {setverdict(pass)}
+ if(isbound(vl_u.r)){setverdict(fail)} else {setverdict(pass)};
+ if(isbound(vl_u.r.i)){setverdict(fail)} else {setverdict(pass)};
+ if(isbound(vl_u.r.x)){setverdict(fail)} else {setverdict(pass)};
+ if(isbound(vl_u.r.c)){setverdict(fail)} else {setverdict(pass)};
+ //checks if the selected item remained the same
+ if(isbound(vl_u.i)){setverdict(pass)}else {setverdict(fail)}
+ if(isbound(vl_u.roi)){setverdict(fail)} else {setverdict(pass)}
+ if(isbound(vl_u.roi[0])){setverdict(fail)}else {setverdict(pass)}
+ if(isbound(vl_u.roi[1])){setverdict(fail)} else {setverdict(pass)}
+}
+
+
+// testcase tc_compilationerror1() runs on unionOper_mycomp {
+// var MyUnion1 vl_u:= c_myunion2;
+// if(isbound(vl_u)) {setverdict(pass)} else {setverdict(fail)}
+// if(isbound(vl_u.roc)){setverdict(fail)} else {setverdict(pass)}
+// if(isbound(vl_u.roc[0])){setverdict(fail)}else {setverdict(pass)}
+// if(isbound(vl_u.r.x)){setverdict(fail)}else {setverdict(pass)}
+// if(isbound(vl_u.roc[99])){setverdict(fail)} else {setverdict(pass)}
+// }
+
+
+
+testcase tc_union_modify() runs on unionOper_mycomp {
+ var MyUnion1 vl_u:= c_myunion2;
+ if(isbound(vl_u)) {setverdict(pass)} else {setverdict(fail)}
+ if(isbound(vl_u.roc)){setverdict(fail)} else {setverdict(pass)}
+ if(isbound(vl_u.roi)){setverdict(fail)} else {setverdict(pass)}
+
+ vl_u:=c_myunion1;
+ if(isbound(vl_u)) {setverdict(pass)} else {setverdict(fail)}
+ if(isbound(vl_u.roc)){setverdict(pass)} else {setverdict(fail)}
+ if(isbound(vl_u.roc[0])){setverdict(pass)}else {setverdict(fail)}
+ if(isbound(vl_u.roc[1])){setverdict(pass)}else {setverdict(fail)}
+ if(isbound(vl_u.roc[2])){setverdict(pass)}else {setverdict(fail)}
+ if(isbound(vl_u.roc[3])){setverdict(fail)}
+ if(isbound(vl_u.roc[99])){setverdict(fail)}
+ if(isbound(vl_u.i)){setverdict(fail)}
+ if(isbound(vl_u.roi)){setverdict(fail)}
+ if(isbound(vl_u.roi[0])){setverdict(fail)}
+ if(isbound(vl_u.roi[1])){setverdict(fail)} else {setverdict(pass)}
+ log(vl_u.roc);
+}
+//expected:error
+testcase tc_sideeffect1() runs on unionOper_mycomp {
+ var MyUnion1 vl_u:= c_myunion1; // { roc:= { "1aa", "2bb", "3cc"}}
+ if(isbound(vl_u.roc[3])){setverdict(fail)}else {setverdict(pass)}
+ if(ispresent(vl_u.roc[3])){setverdict(fail)}else {setverdict(pass)}
+}
+
+//expected:error
+testcase tc_sideeffect2() runs on unionOper_mycomp {
+ var MyUnion1 vl_u:= c_myunion1; // { roc:= { "1aa", "2bb", "3cc"}}
+ var integer vl_oldsize:=0, vl_newsize:=0;
+ vl_oldsize:=sizeof(vl_u.roc);
+
+ if(isbound(vl_u.i)){setverdict(fail)}else {setverdict(pass)}
+
+ if(isbound(vl_u.roc)) {setverdict(pass)}else {setverdict(fail)}
+
+ //checks if size is unchenged
+ if(isbound(vl_u.roc[4])) {setverdict(fail)}else {setverdict(pass)}
+ vl_newsize:=sizeof(vl_u.roc);
+ if(vl_newsize == vl_oldsize) {setverdict(pass)}else {setverdict(fail)}
+ //log(vl_u.i);
+}
+
+ testcase tc_unionOfRecordOfs1_ispresent() runs on unionOper_mycomp {
+ var MyUnion1 vl_u:= c_myunion1;
+ if(ispresent(vl_u)) {setverdict(pass)} else {setverdict(fail)}
+ }
+
+ testcase tc_unionOfRecordOfs2_ispresent() runs on unionOper_mycomp {
+ var MyUnion1 vl_u:= c_myunion1;
+ if(ispresent(vl_u.roc)){setverdict(pass)} else {setverdict(fail)}
+ if(ispresent(vl_u.roc[0])){setverdict(pass)}else {setverdict(fail)}
+ if(ispresent(vl_u.roc[1])){setverdict(pass)}else {setverdict(fail)}
+ if(ispresent(vl_u.roc[2])){setverdict(pass)}else {setverdict(fail)}
+ if(ispresent(vl_u.roc[3])){setverdict(fail)}else {setverdict(pass)}
+ if(ispresent(vl_u.roc[99])){setverdict(fail)}else {setverdict(pass)}
+ if(ispresent(vl_u.i)){setverdict(fail)}else {setverdict(pass)}
+ if(ispresent(vl_u.roi)){setverdict(fail)}else {setverdict(pass)}
+ if(ispresent(vl_u.roi[0])){setverdict(fail)}else {setverdict(pass)}
+ if(ispresent(vl_u.roi[1])){setverdict(fail)} else {setverdict(pass)}
+ log(vl_u.roc);
+ }
+
+ testcase tc_unionOfRecordOfs3_ispresent() runs on unionOper_mycomp {
+ var MyUnion1 vl_u:= c_myunion2;
+ if(ispresent(vl_u)) {setverdict(pass)} else {setverdict(fail,__LINE__)}
+ if(ispresent(vl_u.roc)){setverdict(fail,__LINE__)} else {setverdict(pass)}
+ if(ispresent(vl_u.roc[0])){setverdict(fail,__LINE__)} else {setverdict(pass)}
+ if(ispresent(vl_u.roc[1])){setverdict(fail,__LINE__)} else {setverdict(pass)}
+ if(ispresent(vl_u.roc[2])){setverdict(fail,__LINE__)} else {setverdict(pass)}
+ if(ispresent(vl_u.roc[3])){setverdict(fail,__LINE__)} else {setverdict(pass)}
+ if(ispresent(vl_u.roc[99])){setverdict(fail,__LINE__)} else {setverdict(pass)}
+ if(ispresent(vl_u.r)){setverdict(fail,__LINE__)} else {setverdict(pass)};
+ if(ispresent(vl_u.r.i)){setverdict(fail,__LINE__)} else {setverdict(pass)};
+ if(ispresent(vl_u.r.x)){setverdict(fail,__LINE__)} else {setverdict(pass)};
+ if(ispresent(vl_u.r.c)){setverdict(fail,__LINE__)} else {setverdict(pass)};
+ //checks if the selected item remained the same
+ if(ispresent(vl_u.i)){setverdict(pass)}else {setverdict(fail,__LINE__)}
+ if(ispresent(vl_u.roi)){setverdict(fail,__LINE__)} else {setverdict(pass)}
+ if(ispresent(vl_u.roi[0])){setverdict(fail,__LINE__)}else {setverdict(pass)}
+ if(ispresent(vl_u.roi[1])){setverdict(fail,__LINE__)} else {setverdict(pass)}
+ }
+
+
+ // testcase tc_compilationerror1() runs on unionOper_mycomp {
+ // var MyUnion1 vl_u:= c_myunion2;
+ // if(ispresent(vl_u)) {setverdict(pass)} else {setverdict(fail)}
+ // if(ispresent(vl_u.roc)){setverdict(fail)} else {setverdict(pass)}
+ // if(ispresent(vl_u.roc[0])){setverdict(fail)}else {setverdict(pass)}
+ // if(ispresent(vl_u.r.x)){setverdict(fail)}else {setverdict(pass)}
+ // if(ispresent(vl_u.roc[99])){setverdict(fail)} else {setverdict(pass)}
+ // }
+
+
+
+ testcase tc_union_modify_ispresent() runs on unionOper_mycomp {
+ var MyUnion1 vl_u:= c_myunion2;
+ if(ispresent(vl_u)) {setverdict(pass)} else {setverdict(fail)}
+ if(ispresent(vl_u.roc)){setverdict(fail)} else {setverdict(pass)}
+ if(ispresent(vl_u.roi)){setverdict(fail)} else {setverdict(pass)}
+
+ vl_u:=c_myunion1;
+ if(ispresent(vl_u)) {setverdict(pass)} else {setverdict(fail)}
+ if(ispresent(vl_u.roc)){setverdict(pass)} else {setverdict(fail)}
+ if(ispresent(vl_u.roc[0])){setverdict(pass)}else {setverdict(fail)}
+ if(ispresent(vl_u.roc[1])){setverdict(pass)}else {setverdict(fail)}
+ if(ispresent(vl_u.roc[2])){setverdict(pass)}else {setverdict(fail)}
+ if(ispresent(vl_u.roc[3])){setverdict(fail)}
+ if(ispresent(vl_u.roc[99])){setverdict(fail)}
+ if(ispresent(vl_u.i)){setverdict(fail)}
+ if(ispresent(vl_u.roi)){setverdict(fail)}
+ if(ispresent(vl_u.roi[0])){setverdict(fail)}
+ if(ispresent(vl_u.roi[1])){setverdict(fail)} else {setverdict(pass)}
+ log(vl_u.roc);
+ }
+ //expected:error
+ testcase tc_sideeffect1_ispresent() runs on unionOper_mycomp {
+ var MyUnion1 vl_u:= c_myunion1; // { roc:= { "1aa", "2bb", "3cc"}}
+ if(ispresent(vl_u.roc[2])){setverdict(pass)}else {setverdict(fail)}
+ if(ispresent(vl_u.roc[3])){setverdict(fail)}else {setverdict(pass)}
+ }
+
+ //expected:error
+ testcase tc_sideeffect2_ispresent() runs on unionOper_mycomp {
+ var MyUnion1 vl_u:= c_myunion1; // { roc:= { "1aa", "2bb", "3cc"}}
+ var integer vl_oldsize:=0, vl_newsize:=0;
+ vl_oldsize:=sizeof(vl_u.roc);
+
+ if(ispresent(vl_u.i)){setverdict(fail)}else {setverdict(pass)}
+
+ if(ispresent(vl_u.roc)) {setverdict(pass)}else {setverdict(fail)}
+
+ //checks if size is unchenged
+ if(ispresent(vl_u.roc[4])) {setverdict(fail)}else {setverdict(pass)}
+ vl_newsize:=sizeof(vl_u.roc);
+ if(vl_newsize == vl_oldsize) {setverdict(pass)}else {setverdict(fail)}
+ //log(vl_u.i);
+ }
+
+type set InnerSet {
+ integer num,
+ charstring str
+}
+
+type record InnerRec {
+ integer num,
+ charstring str
+}
+
+type union InnerUni {
+ InnerSet s,
+ InnerRec r
+}
+
+type record Outer {
+ InnerUni uni1 optional,
+ InnerUni uni2,
+ record of InnerUni unis
+}
+
+//modulepar Outer mp;
+
+// Test case for artf703093 : A union with an unbound alternative should itself be unbound
+// All unions in the module parameter and the variable declared in the test case should
+// be unbound (instead of being bound with an unbound alternative).
+// Copying the record containing the unions should be possible, too, without errors.
+testcase tc_union_with_unbound_alternative() runs on unionOper_mycomp {
+// if (isbound(mp.uni1)) {
+// setverdict(fail, "mp.uni1 is bound: ", mp.uni1);
+// }
+// if (isbound(mp.uni2)) {
+// setverdict(fail, "mp.uni2 is bound: ", mp.uni2);
+// }
+// if (isbound(mp.unis[0])) {
+// setverdict(fail, "mp.unis[0] is bound: ", mp.unis[0]);
+// }
+// if (isbound(mp.unis[1])) {
+// setverdict(fail, "mp.unis[1] is bound: ", mp.unis[1]);
+// }
+
+ var Outer x := {
+ uni1 := { r := { num := -, str := - } },
+ uni2 := { s := { num := -, str := - } },
+ unis := {
+ { r := { num := -, str := - } },
+ { s := { num := -, str := - } }
+ }
+ };
+ if (isbound(x.uni1)) {
+ setverdict(fail, "x.uni1 is bound: ", x.uni1);
+ }
+ if (isbound(x.uni2)) {
+ setverdict(fail, "x.uni2 is bound: ", x.uni2);
+ }
+ if (isbound(x.unis[0])) {
+ setverdict(fail, "x.unis[0] is bound: ", x.unis[0]);
+ }
+ if (isbound(x.unis[1])) {
+ setverdict(fail, "x.unis[1] is bound: ", x.unis[1]);
+ }
+
+ var Outer copy := x;
+ if (isbound(copy.uni1)) {
+ setverdict(fail, "copied x.uni1 is bound: ", copy.uni1);
+ }
+ if (isbound(copy.uni2)) {
+ setverdict(fail, "copied x.uni2 is bound: ", copy.uni2);
+ }
+ if (isbound(copy.unis[0])) {
+ setverdict(fail, "copied x.unis[0] is bound: ", copy.unis[0]);
+ }
+ if (isbound(copy.unis[1])) {
+ setverdict(fail, "copied x.unis[1] is bound: ", copy.unis[1]);
+ }
+
+// copy := mp;
+// if (isbound(copy.uni1)) {
+// setverdict(fail, "copied mp.uni1 is bound: ", copy.uni1);
+// }
+// if (isbound(copy.uni2)) {
+// setverdict(fail, "copied mp.uni2 is bound: ", copy.uni2);
+// }
+// if (isbound(copy.unis[0])) {
+// setverdict(fail, "copied mp.unis[0] is bound: ", copy.unis[0]);
+// }
+// if (isbound(copy.unis[1])) {
+// setverdict(fail, "copied mp.unis[1] is bound: ", copy.unis[1]);
+// }
+ setverdict(pass);
+}
+
+control {
+ const typedefunionComp_myunion cl_1:= { x1:={ x1:=1, x2:=1.2 }}; // constant in control part
+ const typedefunionComp_myunion cl_2:= { x2:={ '12AB'O, 'CD12'O }};
+ const typedefunionComp_myunion cl_3:= { x3:={ x1:=2, x2:=1.3 }};
+ const typedefunionComp_myunion cl_4:= { x4:={ "a", "b", "c" }};
+ const typedefunionComp_myunion cl_5:= { x5:={ x1 :=3 }};
+ const typedefunionComp_myunion cl_6:= { x6:={ 1,2,3}};
+ var typedefunionComp_myunion vl_1; // variable in control part
+ var typedefunionComp_myunion vl_2;
+ var typedefunionComp_myunion vl_3;
+ var typedefunionComp_myunion vl_4;
+ var typedefunionComp_myunion vl_5;
+ var typedefunionComp_myunion vl_6;
+
+ execute(unionAssign());
+ execute(unionAssignEnum());
+ execute(unionAssignRec());
+ execute(unionAssignRecof());
+ execute(unionAssignSet());
+ execute(unionAssignSetof());
+ execute(unionAssignUnion());
+ execute(unionAssignElem());
+ execute(unionAssignElemEnum());
+ execute(unionAssignElemRec());
+ execute(unionAssignElemRecof());
+ execute(unionAssignElemSet());
+ execute(unionAssignElemSetof());
+ execute(unionAssignElemUnion());
+ execute(unionConst());
+ execute(unionConstEnum());
+ execute(unionConstRec());
+ execute(unionConstRecof());
+ execute(unionConstSet());
+ execute(unionConstSetof());
+ execute(unionConstUnion())
+ execute(unionComp());
+ execute(unionCompSame());
+ execute(unionCompEnum());
+ execute(unionCompRec());
+ execute(unionCompRecof());
+ execute(unionCompSet());
+ execute(unionCompSetof());
+ execute(unionCompUnion());
+ execute(unionSubtypes());
+ execute(unionIsvalue());
+ execute(unionIsbound());
+
+ execute(tc_unionOfRecordOfs1());
+ execute(tc_unionOfRecordOfs2());
+ execute(tc_union_modify());
+ execute(tc_sideeffect1());
+ execute(tc_sideeffect2());
+ execute(tc_unionOfRecordOfs1_ispresent());
+ execute(tc_unionOfRecordOfs2_ispresent());
+ execute(tc_unionOfRecordOfs3_ispresent());
+ execute(tc_union_modify_ispresent());
+ execute(tc_sideeffect1_ispresent());
+ execute(tc_sideeffect2_ispresent());
+ execute(tc_union_with_unbound_alternative());
+}
+}
diff --git a/Regression_Test_java/src/TverdictOper.ttcn b/Regression_Test_java/src/TverdictOper.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..c3a5d7813436d8004c6874025952a828d1cbad2b
--- /dev/null
+++ b/Regression_Test_java/src/TverdictOper.ttcn
@@ -0,0 +1,350 @@
+/******************************************************************************
+ * 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
+ * Godar, Marton
+ * Kovacs, Ferenc
+ * Raduly, Csaba
+ * Szabados, Kristof
+ * Szabo, Janos Zoltan – initial implementation
+ *
+ ******************************************************************************/
+module TverdictOper
+{ type component verdictOper_mycomp {};
+ const verdicttype verdictOper_const1:=fail;
+
+testcase verdictAssign() runs on verdictOper_mycomp {
+ var verdicttype x1:=inconc;
+ var verdicttype x2;
+ x2:=pass;
+ if (x1==inconc) {setverdict(pass);} //at declaration
+ else {setverdict(fail);}
+ if (x2==pass) {setverdict(pass);} //later
+ else {setverdict(fail);}
+}
+
+testcase verdictConst() runs on verdictOper_mycomp {
+ const verdicttype const1:=inconc;
+ if (verdictOper_const1==fail) {setverdict(pass);} //definition part declaration
+ else {setverdict(fail);}
+ if (const1==inconc) {setverdict(pass);} //testcase
+ else {setverdict(fail);}
+}
+
+
+testcase verdictCompEq() runs on verdictOper_mycomp {
+var verdicttype x1,x2,x3;
+ x1:=pass;
+ x2:=pass;
+ x3:=inconc;
+ if (x1==x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x3==x2)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1==pass) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1==fail)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (pass==x1) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(inconc==x1)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (pass==pass) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(pass==fail)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase verdictCompNotEq() runs on verdictOper_mycomp
+{ var verdicttype x1,x2,x3;
+ x1:=pass;
+ x2:=fail;
+ x3:=pass;
+ if (x1!=x2) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (not(x1!=x3)) {setverdict(pass);} //variable_variable
+ else {setverdict(fail);}
+ if (x1!=fail) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (not(x1!=pass)) {setverdict(pass);} //variable_value
+ else {setverdict(fail);}
+ if (pass!=x2) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (not(fail!=x2)) {setverdict(pass);} //value_variable
+ else {setverdict(fail);}
+ if (inconc!=fail) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+ if (not(pass!=pass)) {setverdict(pass);} //value_value
+ else {setverdict(fail);}
+}
+
+testcase verdictSetGet() runs on verdictOper_mycomp {
+ var verdicttype x1;
+ if (getverdict != none) { setverdict(fail); stop; }
+ setverdict(pass);
+ x1 := getverdict;
+ if (x1 != pass) { setverdict(fail); stop; }
+}
+
+testcase verdictSet_None() runs on verdictOper_mycomp {
+ // do nothing
+}
+
+testcase verdictSet_n_None() runs on verdictOper_mycomp {
+ setverdict(none);
+}
+
+testcase verdictSet_p_Pass() runs on verdictOper_mycomp {
+ setverdict(pass);
+}
+
+testcase verdictSet_i_Inconc() runs on verdictOper_mycomp {
+ setverdict(inconc);
+}
+
+testcase verdictSet_f_Fail() runs on verdictOper_mycomp {
+ setverdict(fail, "fail alone is fail");
+}
+
+testcase verdictSet_p_i_Inconc() runs on verdictOper_mycomp {
+ setverdict(pass);
+ setverdict(inconc);
+}
+
+testcase verdictSet_p_f_Fail() runs on verdictOper_mycomp {
+ setverdict(pass);
+ setverdict(fail, "fail after pass is fail");
+}
+
+testcase verdictSet_p_n_Pass() runs on verdictOper_mycomp {
+ setverdict(pass);
+ setverdict(none);
+}
+
+testcase verdictSet_i_p_Inconc() runs on verdictOper_mycomp {
+ setverdict(inconc);
+ setverdict(pass);
+}
+
+testcase verdictSet_i_f_Fail() runs on verdictOper_mycomp {
+ setverdict(inconc);
+ setverdict(fail);
+}
+
+testcase verdictSet_i_n_Inconc() runs on verdictOper_mycomp {
+ setverdict(inconc);
+ setverdict(none);
+}
+
+testcase verdictSet_f_p_Fail() runs on verdictOper_mycomp {
+ setverdict(fail);
+ setverdict(pass, "pass after fail is still fail");
+}
+
+testcase verdictSet_f_i_Fail() runs on verdictOper_mycomp {
+ setverdict(fail);
+ setverdict(inconc);
+}
+
+testcase verdictSet_f_n_Fail() runs on verdictOper_mycomp {
+ setverdict(fail);
+ setverdict(none);
+}
+
+testcase verdictSet_n_p_Pass() runs on verdictOper_mycomp {
+ setverdict(none);
+ setverdict(pass);
+}
+
+testcase verdictSet_n_i_Inconc() runs on verdictOper_mycomp {
+ setverdict(none);
+ setverdict(inconc);
+}
+
+testcase verdictSet_n_f_Fail() runs on verdictOper_mycomp {
+ setverdict(none);
+ setverdict(fail);
+}
+
+/*--- VERDICT REASON -----------------------------------------------*/
+
+modulepar octetstring VR_mp := '12353425'O;
+const float VR_fl := 1.0;
+//type record VR_rec {
+// integer i,
+// boolean b
+//}
+//
+//testcase verdict_reason() runs on verdictOper_mycomp {
+//
+// template VR_rec VR_tmpl := { i := 1235, b := true};
+// var integer VR_int := 5;
+// var boolean VR_bool;
+// timer VR_timer := 5.0;
+// VR_timer.start;
+//
+// setverdict(pass, "Module parameter identifier: ", VR_mp);
+// setverdict(pass, "Literal value: ", "this is the value");
+// setverdict(pass, "Data constant identifier: ", VR_fl);
+// setverdict(pass, "Template instance: ", VR_tmpl);
+// setverdict(pass, "Data type variable identifier: ", VR_int);
+// setverdict(pass, "Uninitialized data type variable identifier: ", VR_bool);
+// setverdict(pass, "self component type variable identifier: ", self);
+// setverdict(pass, "mtc component type variable identifier: ", mtc);
+// setverdict(pass, "system component type variable identifier: ", system);
+// setverdict(pass, "Timer running operation: ", VR_timer.running);
+// setverdict(pass, "Timer name: ", VR_timer);
+// setverdict(pass, "Getverdict operation: ", getverdict);
+// setverdict(pass, "More parameters: ", getverdict, system, self, VR_tmpl, VR_mp, "and this is the and of all logging...");
+// setverdict(pass);
+//}
+
+type verdicttype typedefbasic_myverdt;
+type verdicttype myv1 (pass, fail, none, inconc)
+type myv1 myv2
+type verdicttype myv3 (error)
+type verdicttype myv4 (myv1, myv3)
+const myv1 c_myv1 := pass
+const myv4 c_myv2 := none
+template myv1 t_myv1 := f_v1()
+template myv1 t_myv2 := f_v2()
+template myv4 t_myv3 := fail
+
+modulepar myv1 mod1 := c_myv1
+
+function f_v1() return myv1 { return inconc }
+function f_v2() return myv1 { return c_myv1 }
+
+testcase verdictSubtypes() runs on verdictOper_mycomp {
+ if (pass == mod1 and mod1 == pass and f_v1() != f_v2()) { setverdict(pass) }
+ else { setverdict(fail) }
+ var template myv3 vt_v1 := error
+ var myv3 v_v1 := valueof(vt_v1)
+ if (error == v_v1 and match(error, vt_v1)) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+testcase verdictIsbound() runs on verdictOper_mycomp {
+ var verdicttype v0;
+ var verdicttype v1 := pass;
+ if ( isvalue(v0) ) { setverdict(fail); } else { setverdict(pass); };
+ if ( isvalue(v1) ) { setverdict(pass); } else { setverdict(fail); };
+}
+
+control{
+ var integer fault_count := 0;
+ if (execute(verdictAssign()) != pass) {
+ log("Test case verdictAssign has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictConst()) != pass) {
+ log("Test case verdictConst has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictCompEq()) != pass) {
+ log("Test case verdictCompEq has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictCompNotEq()) != pass) {
+ log("Test case verdictCompNotEq has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSetGet()) != pass) {
+ log("Test case verdictSetGet has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_None()) != none) {
+ log("Test case verdictSet_None has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_n_None()) != none) {
+ log("Test case verdictSet_n_None has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_p_Pass()) != pass) {
+ log("Test case verdictSet_p_Pass has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_i_Inconc()) != inconc) {
+ log("Test case verdictSet_i_Inconc has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_f_Fail()) != fail) {
+ log("Test case verdictSet_f_Fail has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_p_i_Inconc()) != inconc) {
+ log("Test case verdictSet_p_i_Inconc has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_p_f_Fail()) != fail) {
+ log("Test case verdictSet_p_f_Fail has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_p_n_Pass()) != pass) {
+ log("Test case verdictSet_p_n_Pass has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_i_p_Inconc()) != inconc) {
+ log("Test case verdictSet_i_p_Inconc has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_i_f_Fail()) != fail) {
+ log("Test case verdictSet_i_f_Fail has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_i_n_Inconc()) != inconc) {
+ log("Test case verdictSet_i_n_Inconc has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_f_p_Fail()) != fail) {
+ log("Test case verdictSet_f_p_Fail has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_f_i_Fail()) != fail) {
+ log("Test case verdictSet_f_i_Fail has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_f_n_Fail()) != fail) {
+ log("Test case verdictSet_f_n_Fail has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_n_p_Pass()) != pass) {
+ log("Test case verdictSet_n_p_Pass has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_n_i_Inconc()) != inconc) {
+ log("Test case verdictSet_n_i_Inconc has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictSet_n_f_Fail()) != fail) {
+ log("Test case verdictSet_n_f_Fail has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+// if (execute(verdict_reason()) != pass) {
+// log("Test case verdict_reason has unexpected verdict.");
+// fault_count := fault_count + 1;
+// }
+ if (execute(verdictSubtypes()) != pass) {
+ log("Test case verdictSubtypes() has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (execute(verdictIsbound()) != pass) {
+ log("Test case verdictSubtypes() has unexpected verdict.");
+ fault_count := fault_count + 1;
+ }
+ if (fault_count == 0) {
+ log("ALL TEST CASES HAVE PASSED!!!");
+ } else {
+ var integer i := 0;
+ log("NUMBER OF FAILED TEST CASES: ", fault_count);
+ // this will cause an error
+ i := 1 / i;
+ }
+ }
+}
diff --git a/Regression_Test_java/src/all_from/all_from.ttcn b/Regression_Test_java/src/all_from/all_from.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..042aacb214c3c89a2bad204797b125764260ca4d
--- /dev/null
+++ b/Regression_Test_java/src/all_from/all_from.ttcn
@@ -0,0 +1,1543 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module all_from { // ETSI CR 6088
+import from types all;
+import from functions all;
+
+template RoI t_imported_RoI1 := {1, 2, (6..9)};
+template RoI t_imported_RoI2 := {1, *, 3};
+template RoI t_imported_RoI3 := {20,21,22};
+template RoI t_imported_RoI4 := {1, ?, 3};
+//for permutation:
+template RoI t_imported_RoI1_P := {1, 2, *};
+template RoI t_imported_RoI3_P := {1, 2, 3};
+template RoI t_imported_RoI7_P := {1, 2, ?};
+
+//===========Set of Integer================================
+template SoI t_imported_SoI1 := {1,2,(6..9)};
+template SoI t_imported_SoI2 := {1, *, 3};
+template SoI t_imported_SoI3 := {20,21,22};
+
+//just to test these types as well:
+modulepar RoI tsp_RoI3 := {20,21,22};
+modulepar RoI tsp_SoI3 := {20,21,22};
+
+const RoI c_RoI3 := {20,21,22};
+const SoI c_SoI3 := {20,21,22};
+
+// Test Target:
+// ETSI ES 201 873-1 v?.?
+// B 1.2.1 Template List
+//"It can be used on values of all types"
+
+//============Record of Integer============================
+template RoI t_RoI1 := {1, 2, (6..9)};
+template RoI t_RoI2 := {1, *, 3};
+template RoI t_RoI3 := {20,21,22};
+template RoI t_RoI4 := {1, ?, 3};
+
+template integer t_i0 := (all from t_RoI1);
+template integer t_i0_eq := (1, 2, (6..9));
+
+template integer t_i1 := (all from t_RoI1, 100);
+template integer t_i1_eq := (1, 2, (6..9), 100);
+
+template integer t_i2 := (-1,0,all from t_RoI1, 100);
+template integer t_i2_eq:=(-1,0,1, 2, (6..9),100);
+
+template integer t_i3 := (-1,0,all from t_RoI1, all from t_RoI3, 100);
+template integer t_i3_eq := (-1,0,1, 2, (6..9), 20,21,22, 100);
+
+template integer t_i4 := (-1,0,all from t_RoI1, 100, all from t_RoI3);
+template integer t_i4_eq := (-1,0,1, 2, (6..9),100,20,21,22);
+
+template integer t_i5 := (-1,0,all from t_RoI1, 100,all from t_RoI3,all from t_RoI3 ); //repetition
+template integer t_i5_eq := (-1,0,1, 2, (6..9),100,20,21,22,20,21,22);
+
+template integer t_i6 := (-1,0,all from t_RoI1, 100, all from t_RoI3,all from t_RoI3,all from t_RoI3); //repetition
+template integer t_i6_eq := (-1,0,1, 2, (6..9),100,20,21,22,20,21,22,20,21,22);
+
+template integer t_i7 := (all from t_RoI4,100);
+template integer t_i7_eq := (1,?,3,100);
+
+template integer t_i8 := (100,all from t_RoI4);
+template integer t_i8_eq := (100,1,?,3);
+
+template integer t_i9 := (100,all from t_RoI4,-1);
+template integer t_i9_eq := (100,1,?,3,-1);
+//NEG TEST: template integer t_i10 := ((all from t_RoI2),100); //<== WHY not if the previous three accepted?
+//NEG TEST: template integer t_i11 := (100,all from t_RoI2);
+//NEG TEST: template integer t_i12 := (100,all from t_RoI2,-1);
+
+//from modulepar:
+template integer t_i13roi := (all from tsp_RoI3);
+template integer t_i13_eq := (20,21,22);
+template integer t_i13soi := (all from tsp_SoI3);
+
+//from const:
+template integer t_i13roi_c := (all from c_RoI3);
+template integer t_i13soi_c := (all from c_SoI3);
+
+
+//=== All from referring remote templates (imported templates)
+template integer t_importing_i0 := (all from t_imported_RoI1);
+template integer t_importing_i1 := (all from t_imported_RoI1, 100);
+template integer t_importing_i2 := (-1,0,all from t_imported_RoI1, 100);
+template integer t_importing_i3 := (-1,0,all from t_imported_RoI1, all from t_imported_RoI3, 100);
+template integer t_importing_i4 := (-1,0,all from t_imported_RoI1, 100, all from t_imported_RoI3);
+template integer t_importing_i5 := (-1,0,all from t_imported_RoI1, 100,all from t_imported_RoI3,all from t_imported_RoI3 ); //repetition
+template integer t_importing_i6 := (-1,0,all from t_imported_RoI1, 100, all from t_imported_RoI3,all from t_imported_RoI3,all from t_imported_RoI3); //repetition
+template integer t_importing_i7 := (all from t_imported_RoI4,100);
+template integer t_importing_i8 := (100,all from t_imported_RoI4);
+template integer t_importing_i9 := (100,all from t_imported_RoI4,-1);
+
+
+//===========Set of Integer================================
+template SoI t_SoI1 := {1,2,(6..9)};
+template SoI t_SoI2 := {1, *, 3};
+template SoI t_SoI3 := {20,21,22};
+
+template integer t_i0s := (all from t_SoI1);
+template integer t_i0s_eq := ( 1,2,(6..9));
+
+template integer t_i1s := (all from t_SoI1, 100);
+template integer t_i1s_eq := ( 1,2,(6..9),100);
+// equivalent to (1, 2, (6..9) , 100);
+
+template integer t_i2s := (-1,0,all from t_SoI1, 100);
+template integer t_i2s_eq:=(-1,0,1,2,(6..9), 100);
+
+template integer t_i3s := (-1,0,all from t_SoI1, all from t_SoI3, 100);
+template integer t_i3s_eq := (-1,0,1,2,(6..9),20,21,22, 100);
+
+template integer t_i4s := (-1,0,all from t_SoI1, 100, all from t_SoI3);
+template integer t_i4s_eq := (-1,0,1,2,(6..9),100,20,21,22);
+
+template integer t_i5s := (-1,0,all from t_imported_SoI1, 100, all from t_imported_SoI3,all from t_imported_SoI3 ); //repetition
+template integer t_i5s_eq := (-1,0,1,2,(6..9),100,20,21,22,20,21,22);
+
+template integer t_i6s := (-1,0,all from t_imported_SoI1, 100, all from t_imported_SoI3,all from t_imported_SoI3,all from t_imported_SoI3); //repetition
+template integer t_i6s_eq := (-1,0,1,2,(6..9),100,20,21,22,20,21,22,20,21,22);
+
+template integer t_importing_i0s := (all from t_imported_SoI1);
+template integer t_importing_i1s := (all from t_imported_SoI1, 100);
+template integer t_importing_i2s := (-1,0,all from t_imported_SoI1, 100);
+template integer t_importing_i3s := (-1,0,all from t_imported_SoI1, all from t_imported_SoI3, 100);
+template integer t_importing_i4s := (-1,0,all from t_imported_SoI1, 100, all from t_imported_SoI3);
+template integer t_importing_i5s := (-1,0,all from t_imported_SoI1, 100, all from t_imported_SoI3,all from t_imported_SoI3 ); //repetition
+template integer t_importing_i6s := (-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3,all from t_SoI3); //repetition
+
+//===========Record of of charstring================================
+template RoCS t_RoCS1 := { "apple","banana","","pear"};
+template RoCS t_RoCS2 := { "apples","bananas","","pears"};
+template charstring t_cs1 := ( all from t_RoCS1, "dog" );
+template charstring t_cs1_eq := ( "apple","banana","","pear", "dog" );
+template charstring t_cs2 := ( "treeeeeeeeeeeeee",all from t_RoCS1, "dog", all from t_RoCS2);
+template charstring t_cs2_eq := ( "treeeeeeeeeeeeee","apple","banana","","pear", "dog","apples","bananas","","pears");
+
+//===========Record of octetstring================================
+template RoOS t_RoOS1 := {'ABBA'O,'BABA'O,'FFFF'O,'00'O,'0B'O}
+template octetstring t_os1 := ( all from t_RoOS1 );
+template octetstring t_os1_eq := ('ABBA'O,'BABA'O,'FFFF'O,'00'O,'0B'O)
+template octetstring t_os2 := ( 'AA'O,all from t_RoOS1,all from t_RoOS1);
+
+//====== Embedded templates ====
+//Record
+template MyRecord t_myrec1 := { i:= t_i1, roi:=t_RoI1, soi:=t_SoI1 }
+template MyRecord t_myrec1_eq := { i:= t_i1_eq, roi:=t_RoI1, soi:={1,2,(6..9)} }
+
+template MyRecord t_myrec2 := { i:= t_i2, roi:=t_RoI1, soi:=t_SoI1 }
+template MyRecord t_myrec2_eq := { i:= t_i2_eq, roi:=t_RoI1, soi:= {1,2,(6..9)}}
+
+template MyRecord t_myrec3 := { i:= t_i2, roi:={t_i0s,t_i1}, soi:=t_SoI1 }
+template MyRecord t_myrec3_eq := { i:= t_i2_eq, roi:={( 1,2,(6..9)),(1, 2, (6..9), 100)}, soi:={1,2,(6..9)} }
+
+//Union
+template MyUnion t_myunion1i := { i:= t_i1}
+template MyUnion t_myunion1roi := { roi:={t_i1,t_i1}}
+template MyUnion t_myunion1soi := { soi:={t_i1,t_i1}}
+
+template MyUnion t_myunion1i_eq := { i:= t_i1_eq}
+template MyUnion t_myunion1roi_eq := { roi:= {(1, 2, (6..9)),(1, 2, (6..9))}}
+template MyUnion t_myunion1soi_eq := { soi:= {(1, 2, (6..9)),(1, 2, (6..9))}}
+
+template MyUnion t_myunion2i := { i:= t_i2 }
+template MyUnion t_myunion2roi := { roi:=t_RoI1 }
+template MyUnion t_myunion2soi := { soi:=t_SoI1 }
+
+template MyUnion t_myunion2i_eq := { i:= t_i2_eq }
+template MyUnion t_myunion2roi_eq := { roi:={1, 2,(6..9)} };
+template MyUnion t_myunion2soi_eq := { soi:= {1,2,(6..9)} };
+
+template MyUnion t_myunion3 := { roi:={t_i0s,t_i1}}
+template MyUnion t_myunion3_eq := {roi:={ ( 1,2,(6..9)),(1, 2, (6..9), 100)}}
+
+//Complex
+template RoI t_roiComplex1 := { t_i0s, (all from t_SoI3) };
+template RoI t_roiComplex1_eq := { ( 1,2,(6..9)), (20,21,22)};
+template integer t_complex1 := (all from t_roiComplex1);
+template integer t_complex1_eq := ( ( 1,2,(6..9)), (20,21,22));
+
+//==== function reference =====
+template RoF_int2int t_rofref_int2int := { refers(f_int2int_1),refers(f_int2int_2) }
+template F_int2int t_fref_int2int := ( all from t_rofref_int2int );
+template F_int2int t_fref_int2int_eq := ( refers(f_int2int_1),refers(f_int2int_2) );
+
+//============== Test for Integer List ================================
+
+
+//----- Tests for static templates ------
+
+//real static template, without any manipulation
+testcase tc_checkIntegerValueListTemplate() runs on A
+{
+ var RoI vl_goodValues := { 1,2,6,7,8,9,100};
+ action("t_i1=", t_i1, " will be checked against ",vl_goodValues);
+ var integer N:=sizeof(vl_goodValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (match(vl_goodValues[i], t_i1)) { setverdict(pass); }
+ else { setverdict(fail,vl_goodValues[i], " should match ", t_i1); }
+ }
+
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ action("t_i1=", t_i1, " will be checked against ",vl_badValues);
+ N:=sizeof(vl_badValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (not match(vl_badValues[i], t_i1)) { setverdict(pass); }
+ else { setverdict(fail,vl_badValues[i], " should match ", t_i1); }
+ }
+
+}
+
+//=== 0 ===
+//( 1,2,(6..9));
+testcase tc_checkIntegerValueListTemplate0_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i0,t_i0_eq);
+}
+
+testcase tc_checkImportingIntegerValueListTemplate0_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_importing_i0,t_i0_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate0() runs on A
+{
+ var RoI vl_goodValues := { 1,2,6,7,8,9};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i0,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkImportingIntegerValueListTemplate0() runs on A
+{
+ var RoI vl_goodValues := { 1,2,6,7,8,9};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_importing_i0,vl_goodValues,vl_badValues);
+}
+//=== 1 ===
+//( 1,2,(6..9),100);
+testcase tc_checkIntegerValueListTemplate1_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i1,t_i1_eq);
+}
+
+testcase tc_checkImportingIntegerValueListTemplate1_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_importing_i1,t_i1_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate1() runs on A
+{
+ var RoI vl_goodValues := { 1,2,6,7,8,9,100};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkImportingIntegerValueListTemplate1() runs on A
+{
+ var RoI vl_goodValues := { 1,2,6,7,8,9,100};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_importing_i1,vl_goodValues,vl_badValues);
+}
+//=== 2 ===
+//(-1,0,1,2,(6..9), 100);
+testcase tc_checkIntegerValueListTemplate2_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i2,t_i2_eq);
+}
+
+testcase tc_checkImportingIntegerValueListTemplate2_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_importing_i2,t_i2_eq);
+}
+testcase tc_checkIntegerValueListTemplate2() runs on A
+{
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i2,vl_goodValues,vl_badValues);
+}
+testcase tc_checkImportingIntegerValueListTemplate2() runs on A
+{
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_importing_i2,vl_goodValues,vl_badValues);
+}
+//=== 3 ===
+//(-1,0,1,2,(6..9),20,21,22, 100);
+testcase tc_checkIntegerValueListTemplate3_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i3,t_i3_eq);
+}
+testcase tc_checkIntegerValueListTemplate3() runs on A
+{
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i3,vl_goodValues,vl_badValues);
+}
+//=== 4 ===
+//order;(-1,0,1,2,(6..9),100,20,21,22);
+testcase tc_checkIntegerValueListTemplate4_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i4,t_i4_eq);
+}
+testcase tc_checkIntegerValueListTemplate4() runs on A
+{
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i4,vl_goodValues,vl_badValues);
+}
+
+//=== 5 ===
+//repetition
+//(-1,0,1,2,(6..9),100,20,21,22,20,21,22);
+testcase tc_checkIntegerValueListTemplate5_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i5,t_i5_eq);
+}
+testcase tc_checkIntegerValueListTemplate5() runs on A
+{
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i5,vl_goodValues,vl_badValues);
+}
+
+//=== 6 ===
+//(-1,0,1,2,(6..9),100,20,21,22,20,21,22,20,21,22);
+testcase tc_checkIntegerValueListTemplate6_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i6,t_i6_eq);
+}
+testcase tc_checkIntegerValueListTemplate6() runs on A
+{
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i6,vl_goodValues,vl_badValues);
+}
+//=== 7 ===
+//(1,?,3,100);
+testcase tc_checkIntegerValueListTemplate7_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i7,t_i7_eq);
+}
+testcase tc_checkIntegerValueListTemplate7() runs on A
+{
+ var RoI vl_goodValues := {-1,0,1,2,3,4,5,500,5000};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(t_i7,vl_goodValues,vl_badValues);
+}
+//=== 8 ===
+//(100,all from t_RoI4);
+testcase tc_checkIntegerValueListTemplate8_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i8,t_i8_eq);
+}
+testcase tc_checkIntegerValueListTemplate8() runs on A
+{
+ var RoI vl_goodValues := {-1,0,1,2,3,4,5,500,5000};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(t_i8,vl_goodValues,vl_badValues);
+}
+//=== 9 ===
+//(100,1,?,3,-1);
+testcase tc_checkIntegerValueListTemplate9_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i9,t_i9_eq);
+}
+testcase tc_checkIntegerValueListTemplate9() runs on A
+{
+ var RoI vl_goodValues := {-1,0,1,2,3,4,5,500,5000};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(t_i9,vl_goodValues,vl_badValues);
+}
+
+/* wrong?
+testcase tc_checkIntegerValueListTemplate10() runs on A
+{
+ var RoI vl_goodValues := {-1,0,1,2,3,4,5,500,5000};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(t_i10,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate11() runs on A
+{
+ var RoI vl_goodValues := {-1,0,1,2,3,4,5,500,5000};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(t_i11,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate12() runs on A
+{
+ var RoI vl_goodValues := {-1,0,1,2,3,4,5,500,5000};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(t_i12,vl_goodValues,vl_badValues);
+}
+*/
+
+//=== i13 ===
+//(20,21,22);
+
+testcase tc_checkIntegerValueListTemplate13roi_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i13roi,t_i13_eq);
+}
+testcase tc_checkIntegerValueListTemplate13roi() runs on A
+{
+ var RoI vl_goodValues := {20,21,22};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(t_i13roi,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate13soi_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i13soi,t_i13_eq);
+}
+testcase tc_checkIntegerValueListTemplate13soi() runs on A
+{
+ var RoI vl_goodValues := {20,21,22};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(t_i13soi,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate13roi_c_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i13roi_c,t_i13_eq);
+}
+testcase tc_checkIntegerValueListTemplate13roi_c() runs on A
+{
+ var RoI vl_goodValues := {20,21,22};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(t_i13roi_c,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate13soi_c_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i13soi_c,t_i13_eq);
+}
+testcase tc_checkIntegerValueListTemplate13soi_c() runs on A
+{
+ var RoI vl_goodValues := {20,21,22};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(t_i13soi_c,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkAllFromInFunctionCall_IntegerValueListInTemplate13roi_eq() runs on A{
+ var template integer tl_i := 0;
+ f_createIntegerWithAllFromFromInTemplateFromRoi(t_RoI3,tl_i);
+ f_checkIntTemplateEquivalence(tl_i,t_i13_eq);
+}
+
+testcase tc_checkAllFromInFunctionCall_IntegerValueListInOutTemplate13roi_eq() runs on A{
+ var template integer tl_i := 0;
+ f_createIntegerWithAllFromFromInTemplateFromRoi(t_RoI3,tl_i);
+ f_checkIntTemplateEquivalence(tl_i,t_i13_eq);
+}
+
+testcase tc_checkAllFromInFunctionCall_IntegerValueListInTemplate13soi_eq() runs on A{
+ var template integer tl_i := 0;
+ f_createIntegerWithAllFromFromInTemplateFromSoi(t_SoI3,tl_i);
+ f_checkIntTemplateEquivalence(tl_i,t_i13_eq);
+}
+
+testcase tc_checkAllFromInFunctionCall_IntegerValueListInOutTemplate13soi_eq() runs on A{
+ var template integer tl_i := 0;
+ f_createIntegerWithAllFromFromInTemplateFromSoi(t_SoI3,tl_i);
+ f_checkIntTemplateEquivalence(tl_i,t_i13_eq);
+}
+
+testcase tc_checkAllFromComponentVar_IntegerValueListTemplate13roi_eq() runs on A{
+ var template integer tl_i := (all from v_roi);
+ f_checkIntTemplateEquivalence(tl_i,t_i13_eq);
+}
+
+testcase tc_checkAllFromComponentVar_IntegerValueListTemplate13soi_eq() runs on A{
+ var template integer tl_i := (all from v_soi);
+ f_checkIntTemplateEquivalence(tl_i,t_i13_eq);
+}
+
+//====== templates derived from set of integers
+//=== i0s ===
+//t_i0s_eq := ( 1,2,(6..9));
+
+testcase tc_checkIntegerValueListTemplate0s_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i0s,t_i0s_eq);
+}
+
+testcase tc_checkImportingIntegerValueListTemplate0s_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_importing_i0s,t_i0s_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate0s() runs on A
+{
+ var RoI vl_goodValues := { 1,2,6,7,8,9};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i0s,vl_goodValues,vl_badValues);
+}
+testcase tc_checkImportingIntegerValueListTemplate0s() runs on A
+{
+ var RoI vl_goodValues := { 1,2,6,7,8,9};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_importing_i0s,vl_goodValues,vl_badValues);
+}
+//=== i1s ==
+//t_i1s_eq := ( 1,2,(6..9),100);
+testcase tc_checkIntegerValueListTemplate1s_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i1s,t_i1s_eq);
+}
+testcase tc_checkImportingIntegerValueListTemplate1s_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_importing_i1s,t_i1s_eq);
+}
+testcase tc_checkIntegerValueListTemplate1s() runs on A
+{
+ var RoI vl_goodValues := { 1,2,6,7,8,9,100};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i1s,vl_goodValues,vl_badValues);
+}
+
+//=== i2s ===
+//(-1,0,1,2,(6..9), 100);
+testcase tc_checkIntegerValueListTemplate2s_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i2s,t_i2s_eq);
+}
+testcase tc_checkIntegerValueListTemplate2s() runs on A
+{
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i2s,vl_goodValues,vl_badValues);
+}
+
+//=== i3s ===
+//(-1,0,1,2,(6..9),20,21,22, 100);
+testcase tc_checkIntegerValueListTemplate3s_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i3s,t_i3s_eq);
+}
+testcase tc_checkIntegerValueListTemplate3s() runs on A
+{
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i3s,vl_goodValues,vl_badValues);
+}
+
+//=== i4s ===
+//order
+//(-1,0,1,2,(6..9),100,20,21,22);
+testcase tc_checkIntegerValueListTemplate4s_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i4s,t_i4s_eq);
+}
+testcase tc_checkIntegerValueListTemplate4s() runs on A
+{
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i4s,vl_goodValues,vl_badValues);
+}
+
+//=== i5s ===
+//repetition
+testcase tc_checkIntegerValueListTemplate5s_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i5s,t_i5s_eq);
+}
+testcase tc_checkIntegerValueListTemplate5s() runs on A
+{
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i5s,vl_goodValues,vl_badValues);
+}
+
+//=== i6s ===
+//(-1,0,1,2,(6..9),100,20,21,22,20,21,22,20,21,22);
+testcase tc_checkIntegerValueListTemplate6s_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i6s,t_i6s_eq);
+}
+testcase tc_checkIntegerValueListTemplate6s() runs on A
+{
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i6s,vl_goodValues,vl_badValues);
+}
+//-------- Tests for dynamic templates ( template variables) ----
+//=== i0 ===
+//( 1,2,(6..9));
+testcase tc_checkIntegerValueListTemplate0_eq_dyn() runs on A{
+ var template integer tl_i0 := (all from t_RoI1);
+ f_checkIntTemplateEquivalence(tl_i0,t_i0_eq);
+}
+
+testcase tc_checkImportingIntegerValueListTemplate0_eq_dyn() runs on A{
+ var template integer tl_importing_i0 := (all from t_imported_RoI1);
+ f_checkIntTemplateEquivalence(tl_importing_i0,t_i0_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate0_eq_2dyn() runs on A{
+ var template RoI tl_RoI1 := {1, 2, (6..9)};
+ var template integer tl_i0 := (all from tl_RoI1);
+ f_checkIntTemplateEquivalence(tl_i0,t_i0_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate0_dyn() runs on A
+{
+ var template integer tl_i0 := (all from t_RoI1);
+ var RoI vl_goodValues := { 1,2,6,7,8,9};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i0,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkImportingIntegerValueListTemplate0_dyn() runs on A
+{
+ var template integer tl_importing_i0 := (all from t_imported_RoI1);
+ var RoI vl_goodValues := { 1,2,6,7,8,9};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_importing_i0,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate0_2dyn() runs on A
+{
+ var template RoI tl_RoI1 := {1, 2, (6..9)};
+ var template integer tl_i0 := (all from tl_RoI1);
+ var RoI vl_goodValues := { 1,2,6,7,8,9};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i0,vl_goodValues,vl_badValues);
+}
+//=== i1 ===
+testcase tc_checkIntegerValueListTemplate1_eq_dyn() runs on A
+{
+ var template integer tl_i1 := (all from t_RoI1, 100);
+ f_checkIntTemplateEquivalence(tl_i1,t_i1_eq);
+}
+testcase tc_checkIntegerValueListTemplate1_eq_2dyn() runs on A
+{
+ var template RoI tl_RoI1 := {1, 2, (6..9)};
+ var template integer tl_i1 := (all from tl_RoI1, 100);
+ f_checkIntTemplateEquivalence(tl_i1,t_i1_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate1_dyn() runs on A
+{
+ var template integer tl_i1 := (all from t_RoI1, 100);
+ var RoI vl_goodValues := { 1,2,6,7,8,9,100};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate1_2dyn() runs on A
+{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template integer tl_i1 := (all from tl_RoI1, 100);
+ var RoI vl_goodValues := {1,2,6,7,8,9,100};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i1,vl_goodValues,vl_badValues);
+}
+
+//=== i2 ===
+testcase tc_checkIntegerValueListTemplate2_eq_dyn() runs on A{
+ var template integer tl_i2 := (-1,0,all from t_RoI1, 100);
+ f_checkIntTemplateEquivalence(tl_i2,t_i2_eq);
+}
+testcase tc_checkIntegerValueListTemplate2_eq_2dyn() runs on A{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template integer tl_i2 := (-1,0,all from tl_RoI1, 100);
+ f_checkIntTemplateEquivalence(tl_i2,t_i2_eq);
+}
+testcase tc_checkIntegerValueListTemplate2_dyn() runs on A
+{
+ var template integer tl_i2 := (-1,0,all from t_RoI1, 100);
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i2,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate2_2dyn() runs on A
+{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template integer tl_i2 := (-1,0,all from tl_RoI1, 100);
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i2,vl_goodValues,vl_badValues);
+}
+//=== i3 ===
+
+testcase tc_checkIntegerValueListTemplate3_eq_dyn() runs on A{
+ var template integer tl_i3 := (-1,0,all from t_RoI1, all from t_RoI3, 100);
+ f_checkIntTemplateEquivalence(tl_i3,t_i3_eq);
+}
+testcase tc_checkIntegerValueListTemplate3_eq_2dyn() runs on A{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template RoI tl_RoI3 := {20,21,22};
+ var template integer tl_i3 := (-1,0,all from tl_RoI1, all from tl_RoI3, 100);
+ f_checkIntTemplateEquivalence(tl_i3,t_i3_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate3_dyn() runs on A
+{
+ var template integer tl_i3 := (-1,0,all from t_RoI1, all from t_RoI3, 100);
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,20,21,22,100};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i3,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate3_2dyn() runs on A
+{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template RoI tl_RoI3 := {20,21,22};
+ var template integer tl_i4 := (-1,0,all from tl_RoI1, 100, all from tl_RoI3);
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i4,vl_goodValues,vl_badValues);
+}
+
+//=== i4 ===
+testcase tc_checkIntegerValueListTemplate4_eq_dyn() runs on A{
+ var template integer tl_i4 := (-1,0,all from t_RoI1, 100, all from t_RoI3);
+ f_checkIntTemplateEquivalence(tl_i4,t_i4_eq);
+}
+testcase tc_checkIntegerValueListTemplate4_eq_2dyn() runs on A{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template RoI tl_RoI3 := {20,21,22};
+ var template integer tl_i4 := (-1,0,all from tl_RoI1, 100, all from tl_RoI3);
+ f_checkIntTemplateEquivalence(tl_i4,t_i4_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate4_dyn() runs on A
+{
+ var template integer tl_i4 := (-1,0,all from t_RoI1, 100, all from t_RoI3);
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(t_i4,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate4_2dyn() runs on A
+{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template RoI tl_RoI3 := {20,21,22};
+ var template integer tl_i4 := (-1,0,all from tl_RoI1, 100, all from tl_RoI3);
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i4,vl_goodValues,vl_badValues);
+}
+
+//=== i5 ===
+testcase tc_checkIntegerValueListTemplate5_eq_dyn() runs on A{
+ var template integer tl_i5 := (-1,0,all from t_RoI1, 100,all from t_RoI3,all from t_RoI3 )
+ f_checkIntTemplateEquivalence(tl_i5,t_i5_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate5_eq_2dyn() runs on A{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template RoI tl_RoI3 := {20,21,22};
+ var template integer tl_i5 := (-1,0,all from tl_RoI1, 100,all from tl_RoI3,all from tl_RoI3 )
+ f_checkIntTemplateEquivalence(tl_i5,t_i5_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate5_dyn() runs on A
+{
+ var template integer tl_i5 := (-1,0,all from t_RoI1, 100,all from t_RoI3,all from t_RoI3 )
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i5,vl_goodValues,vl_badValues);
+}
+testcase tc_checkIntegerValueListTemplate5_2dyn() runs on A
+{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template RoI tl_RoI3 := {20,21,22};
+ var template integer tl_i5 := (-1,0,all from tl_RoI1, 100,all from tl_RoI3,all from tl_RoI3 )
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i5,vl_goodValues,vl_badValues);
+}
+
+//=== i6 ===
+testcase tc_checkIntegerValueListTemplate6_eq_dyn() runs on A{
+ var template integer tl_i6 := (-1,0,all from t_RoI1, 100, all from t_RoI3,all from t_RoI3,all from t_RoI3);
+ f_checkIntTemplateEquivalence(tl_i6,t_i6_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate6_eq_2dyn() runs on A{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template RoI tl_RoI3 := {20,21,22};
+ var template integer tl_i6 := (-1,0,all from tl_RoI1, 100, all from tl_RoI3,all from tl_RoI3,all from tl_RoI3);
+ f_checkIntTemplateEquivalence(tl_i6,t_i6_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate6_dyn() runs on A
+{
+ var template integer tl_i6 := (-1,0,all from t_RoI1, 100, all from t_RoI3,all from t_RoI3,all from t_RoI3); //repetition
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i6,vl_goodValues,vl_badValues);
+}
+testcase tc_checkIntegerValueListTemplate6_2dyn() runs on A
+{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template RoI tl_RoI3 := {20,21,22};
+ var template integer tl_i6 := (-1,0,all from t_RoI1, 100, all from t_RoI3,all from t_RoI3,all from t_RoI3); //repetition
+ var RoI vl_goodValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ var RoI vl_badValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i6,vl_goodValues,vl_badValues);
+}
+//=== i7 ===
+testcase tc_checkIntegerValueListTemplate7_eq_dyn() runs on A{
+ var template integer tl_i7 := (all from t_RoI4,100);
+ f_checkIntTemplateEquivalence(tl_i7,t_i7_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate7_eq_2dyn() runs on A{
+ var template RoI tl_RoI4 := {1, ?, 3};
+ var template integer tl_i7 := (all from tl_RoI4,100);
+ f_checkIntTemplateEquivalence(tl_i7,t_i7_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate7_dyn() runs on A
+{
+ var template integer tl_i7 := (all from t_RoI4,100);
+ var RoI vl_goodValues := {-1,0,1,2,3,4,5,500,5000};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(tl_i7,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate7_2dyn() runs on A
+{
+ var template RoI tl_RoI4 := {1, ?, 3};
+ var template integer tl_i7 := (all from tl_RoI4,100);
+ var RoI vl_goodValues := {-1,0,1,2,3,4,5,500,5000};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(tl_i7,vl_goodValues,vl_badValues);
+}
+
+//=== i8 ===
+testcase tc_checkIntegerValueListTemplate8_eq_dyn() runs on A{
+ var template integer tl_i8 := (100,all from t_RoI4);
+ f_checkIntTemplateEquivalence(tl_i8,t_i8_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate8_eq_2dyn() runs on A{
+ var template RoI tl_RoI4 := {1, ?, 3};
+ var template integer tl_i8 := (100,all from tl_RoI4);
+ f_checkIntTemplateEquivalence(tl_i8,t_i8_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate8_dyn() runs on A
+{
+ var template integer tl_i8 := (100,all from t_RoI4);
+ var RoI vl_goodValues := {-1,0,1,2,3,4,5,500,5000};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(tl_i8,vl_goodValues,vl_badValues);
+}
+testcase tc_checkIntegerValueListTemplate8_2dyn() runs on A
+{
+ var template RoI tl_RoI4 := {1, ?, 3};
+ var template integer tl_i8 := (100,all from t_RoI4);
+ var RoI vl_goodValues := {-1,0,1,2,3,4,5,500,5000};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(tl_i8,vl_goodValues,vl_badValues);
+}
+
+//=== i9 ===
+testcase tc_checkIntegerValueListTemplate9_eq_dyn() runs on A{
+ var template integer tl_i9 := (100,all from t_RoI4,-1);
+ f_checkIntTemplateEquivalence(tl_i9,t_i9_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate9_eq_2dyn() runs on A
+{
+ var template RoI tl_RoI4 := {1, ?, 3};
+ var template integer tl_i9 := (100,all from t_RoI4,-1);
+ f_checkIntTemplateEquivalence(tl_i9,t_i9_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate9_dyn() runs on A
+{
+ var template integer tl_i9 := (100,all from t_RoI4,-1);
+ var RoI vl_goodValues := {-1,0,1,2,3,4,5,500,5000};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(tl_i9,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate9_2dyn() runs on A
+{
+ var template RoI tl_RoI4 := {1, ?, 3};
+ var template integer tl_i9 := (100,all from tl_RoI4,-1);
+ var RoI vl_goodValues := {-1,0,1,2,3,4,5,500,5000};
+ var RoI vl_badValues := { };
+ f_checkIntegerTemplate(tl_i9,vl_goodValues,vl_badValues);
+}
+
+//=== 10 ===
+//More complex example
+
+//== 10 eq ==
+testcase tc_RoITemplate10_eq() runs on A
+{
+ f_checkRoITemplateEquivalence(t_roiComplex1,t_roiComplex1_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate10_eq() runs on A
+{
+ f_checkIntTemplateEquivalence(t_complex1,t_complex1_eq);
+}
+
+//local template
+testcase tc_checkIntegerValueListTemplate10_eq_local() runs on A
+{
+ template integer tl_complex1 := (all from t_roiComplex1);
+ f_checkIntTemplateEquivalence(tl_complex1,t_complex1_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate10_eq_dyn() runs on A
+{
+ var template integer tl_complex1 := (all from t_roiComplex1);
+ f_checkIntTemplateEquivalence(tl_complex1,t_complex1_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate10_eq_2dyn() runs on A
+{
+ var template RoI tl_roiComplex1 := { t_i0s, (all from t_SoI3) };
+ var template integer tl_complex1 := (all from tl_roiComplex1);
+ f_checkIntTemplateEquivalence(tl_complex1,t_complex1_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate10_eq_3dyn() runs on A
+{
+ var template integer tl_i0s := (all from t_SoI1);
+ var template RoI tl_roiComplex1 := { tl_i0s, (all from t_SoI3) };
+ var template integer tl_complex1 := (all from tl_roiComplex1);
+ f_checkIntTemplateEquivalence(tl_complex1,t_complex1_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate10_eq_4dyn() runs on A
+{
+ var template SoI tl_SoI1 := {1,2,(6..9)};
+ template SoI tl_SoI3 := {20,21,22};
+
+ var template integer tl_i0s := (all from tl_SoI1);
+ var template RoI tl_roiComplex1 := { tl_i0s, (all from tl_SoI3) };
+ var template integer tl_complex1 := (all from tl_roiComplex1);
+ f_checkIntTemplateEquivalence(tl_complex1,t_complex1_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate10_eq_5dyn() runs on A
+{
+ var template SoI tl_SoI1 := {1,2,(6..9)};
+ var template SoI tl_SoI3 := {20,21,22}; //<=== !!! if this is local then the tc can be compiled
+
+ var template integer tl_i0s := (all from tl_SoI1);
+ var template RoI tl_roiComplex1 := { tl_i0s, (all from tl_SoI3) };//compile error
+ var template integer tl_complex1 := (all from tl_roiComplex1);
+ f_checkIntTemplateEquivalence(tl_complex1,t_complex1_eq);
+}
+//=== 10 check values ==
+testcase tc_checkIntegerValueListTemplate10() runs on A
+{
+ var RoI vl_goodValues := {1,2,6,7,8,9,20,21,22};
+ var RoI vl_badValues := { 0,3,4,5,10,19,23};
+ f_checkIntegerTemplate(t_complex1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate10_dyn() runs on A
+{
+ var template integer tl_complex1 := (all from t_roiComplex1);
+ var RoI vl_goodValues := {1,2,6,7,8,9,20,21,22};
+ var RoI vl_badValues := { 0,3,4,5,10,19,23};
+ f_checkIntegerTemplate(tl_complex1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate10_loc_dyn() runs on A
+{
+ template RoI tl_roiComplex1 := { t_i0s, (all from t_SoI3) }; //local template def
+ var template integer tl_complex1 := (all from tl_roiComplex1); //dyn template def
+
+ var RoI vl_goodValues := {1,2,6,7,8,9,20,21,22};
+ var RoI vl_badValues := { 0,3,4,5,10,19,23};
+ f_checkIntegerTemplate(tl_complex1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate10_2loc_2dyn () runs on A
+{
+ template SoI tl_SoI1 := {1,2,(6..9)}; //local template def
+ template SoI tl_SoI3 := {20,21,22}; //local template def
+ var template RoI tl_roiComplex1 := { (all from tl_SoI1), (all from tl_SoI3) };
+ var template integer tl_complex1 := (all from tl_roiComplex1);
+
+ var RoI vl_goodValues := {1,2,6,7,8,9,20,21,22};
+ var RoI vl_badValues := { 0,3,4,5,10,19,23};
+ f_checkIntegerTemplate(tl_complex1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate10_3loc_2dyn () runs on A
+{
+ template SoI tl_SoI1 := {1,2,(6..9)}; //local template def
+ template SoI tl_SoI3 := {20,21,22}; //local template def
+ template integer tl_i0s := (all from tl_SoI1); //local template def
+ var template RoI tl_roiComplex1 := { tl_i0s, (all from tl_SoI3) };
+ var template integer tl_complex1 := (all from tl_roiComplex1);
+
+ var RoI vl_goodValues := {1,2,6,7,8,9,20,21,22};
+ var RoI vl_badValues := { 0,3,4,5,10,19,23};
+ f_checkIntegerTemplate(tl_complex1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate10_1dyn_1loc_3dyn() runs on A
+{
+ var template SoI tl_SoI1 := {1,2,(6..9)};
+ template SoI tl_SoI3 := {20,21,22};
+ var template integer tl_i0s := (all from tl_SoI1);
+ var template RoI tl_roiComplex1 := { tl_i0s, (all from tl_SoI3) };
+ var template integer tl_complex1 := (all from tl_roiComplex1);
+
+ var RoI vl_goodValues := {1,2,6,7,8,9,20,21,22};
+ var RoI vl_badValues := { 0,3,4,5,10,19,23};
+ f_checkIntegerTemplate(tl_complex1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate10_2loc_3dyn () runs on A
+{
+ template SoI tl_SoI1 := {1,2,(6..9)};
+ template SoI tl_SoI3 := {20,21,22};
+ var template integer tl_i0s := (all from tl_SoI1);
+ var template RoI tl_roiComplex1 := { tl_i0s, (all from tl_SoI3) };
+ var template integer tl_complex1 := (all from tl_roiComplex1);
+ var RoI vl_goodValues := {1,2,6,7,8,9,20,21,22};
+ var RoI vl_badValues := { 0,3,4,5,10,19,23};
+ f_checkIntegerTemplate(tl_complex1,vl_goodValues,vl_badValues);
+}
+
+// The following two thestcases are critical:
+
+//PASS
+testcase tc_checkIntegerValueListTemplate10_6dyn() runs on A
+{
+ var template SoI tl_SoI1 := {1,2,(6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template integer tl_i0s := (all from tl_SoI1);
+ var template integer tl_i1s := (all from tl_SoI3); //<===this helps to compile
+ var template RoI tl_roiComplex1 := { tl_i0s,tl_i1s};
+ var template integer tl_complex1 := (all from tl_roiComplex1);
+ var RoI vl_goodValues := {1,2,6,7,8,9,20,21,22};
+ var RoI vl_badValues := { 0,3,4,5,10,19,23};
+ f_checkIntegerTemplate(tl_complex1,vl_goodValues,vl_badValues);
+}
+
+
+testcase tc_checkIntegerValueListTemplate10_5dyn() runs on A
+{
+ var template SoI tl_SoI1 := {1,2,(6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template integer tl_i0s := (all from tl_SoI1);
+ var template RoI tl_roiComplex1 := { tl_i0s, (all from tl_SoI3) };
+ var template integer tl_complex1 := (all from tl_roiComplex1);
+
+ var RoI vl_goodValues := {1,2,6,7,8,9,20,21,22};
+ var RoI vl_badValues := { 0,3,4,5,10,19,23};
+ f_checkIntegerTemplate(tl_complex1,vl_goodValues,vl_badValues);
+}
+
+
+testcase tc_checkIntegerValueListTemplate10_4dyn() runs on A
+{
+ var template SoI tl_SoI1 := {1,2,(6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template RoI tl_roiComplex1 := { (all from tl_SoI1), (all from tl_SoI3) };
+ var template integer tl_complex1 := (all from tl_roiComplex1);
+
+ var RoI vl_goodValues := {1,2,6,7,8,9,20,21,22};
+ var RoI vl_badValues := { 0,3,4,5,10,19,23};
+ f_checkIntegerTemplate(tl_complex1,vl_goodValues,vl_badValues);
+}
+
+//+++++++++ NEGATIVE TEST+++++++++++++++++++++++++
+
+// see: TTCN3_SA_13_TD.script
+
+//====== Dynamic Templates for Set Of Integer =====
+
+//=== i0s ===
+//t_i0s_eq := ( 1,2,(6..9));
+
+testcase tc_checkIntegerValueListTemplate0s_eq_dyn() runs on A{
+ var template integer tl_i0s := (all from t_SoI1);
+ f_checkIntTemplateEquivalence(tl_i0s,t_i0s_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate0s_eq_2dyn() runs on A{
+ var template SoI tl_SoI1 := {1,2,(6..9)};
+ var template integer tl_i0s := (all from tl_SoI1);
+ f_checkIntTemplateEquivalence(tl_i0s,t_i0s_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate0s_dyn() runs on A
+{
+ var template integer tl_i0s := (all from t_SoI1);
+ var RoI vl_goodValues := { 1,2,6,7,8,9};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i0s,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate0s_2dyn() runs on A
+{
+ var template SoI tl_SoI1 := {1,2,(6..9)};
+ var template integer tl_i0s := (all from tl_SoI1);
+ var RoI vl_goodValues := { 1,2,6,7,8,9};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i0s,vl_goodValues,vl_badValues);
+}
+
+//=== i1s ==
+//t_i1s_eq := ( 1,2,(6..9),100);
+testcase tc_checkIntegerValueListTemplate1s_eq_dyn() runs on A{
+ var template integer tl_i1s := (all from t_SoI1, 100);
+ f_checkIntTemplateEquivalence(tl_i1s,t_i1s_eq);
+}
+
+testcase tc_checkIntegerValueListTemplate1s_eq_2dyn() runs on A{
+ var template SoI tl_SoI1 := {1,2,(6..9)};
+ var template integer tl_i1s := (all from tl_SoI1, 100);
+ f_checkIntTemplateEquivalence(tl_i1s,t_i1s_eq);
+}
+
+
+testcase tc_checkIntegerValueListTemplate1s_dyn() runs on A
+{
+ var template integer tl_i1s := (all from t_SoI1, 100);
+ var RoI vl_goodValues := { 1,2,6,7,8,9,100};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i1s,vl_goodValues,vl_badValues);
+}
+
+testcase tc_checkIntegerValueListTemplate1s_2dyn() runs on A
+{
+ var template SoI tl_SoI1 := {1,2,(6..9)};
+ var template integer tl_i1s := (all from tl_SoI1, 100);
+ var RoI vl_goodValues := { 1,2,6,7,8,9,100};
+ var RoI vl_badValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ f_checkIntegerTemplate(tl_i1s,vl_goodValues,vl_badValues);
+}
+
+
+//=========================================================
+//===== Test for Record of charstring =====================
+//=========================================================
+
+//=== cs1 ===
+testcase tc_CharstringTemplate1_eq() runs on A
+{
+ f_checkCharstringTemplateEquivalence(t_cs1,t_cs1_eq);
+}
+
+testcase tc_CharstringTemplate1_eq_local() runs on A
+{
+ template charstring tl_cs1 := ( all from t_RoCS1, "dog" );
+ f_checkCharstringTemplateEquivalence(tl_cs1,t_cs1_eq);
+}
+
+testcase tc_CharstringTemplate1_eq_dyn() runs on A
+{
+ var template charstring tl_cs1 := ( all from t_RoCS1, "dog" );
+ f_checkCharstringTemplateEquivalence(tl_cs1,t_cs1_eq);
+}
+
+testcase tc_CharstringTemplate1_eq_2dyn() runs on A
+{
+ var template RoCS tl_RoCS1 := { "apple","banana","","pear"};
+ var template charstring tl_cs1 := ( all from tl_RoCS1, "dog" );
+ f_checkCharstringTemplateEquivalence(tl_cs1,t_cs1_eq);
+}
+
+testcase tc_CharstringTemplate1() runs on A
+{
+ var RoCS vl_goodValues := { "apple","banana","","pear", "dog" };
+ var RoCS vl_badValues := { "house","apples" };
+ f_checkCharstringTemplate(t_cs1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_CharstringTemplate1_local() runs on A
+{
+ template charstring tl_cs1 := ( all from t_RoCS1, "dog" )
+ var RoCS vl_goodValues := { "apple","banana","","pear", "dog" };
+ var RoCS vl_badValues := { "house","apples" };
+ f_checkCharstringTemplate(tl_cs1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_CharstringTemplate1_dyn() runs on A
+{
+ var template charstring tl_cs1 := ( all from t_RoCS1, "dog" )
+ var RoCS vl_goodValues := { "apple","banana","","pear", "dog" };
+ var RoCS vl_badValues := { "house","apples" };
+ f_checkCharstringTemplate(tl_cs1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_CharstringTemplate1_2dyn() runs on A
+{
+ var template RoCS tl_RoCS1 := { "apple","banana","","pear"};
+ var template charstring tl_cs1 := ( all from tl_RoCS1, "dog" )
+ var RoCS vl_goodValues := { "apple","banana","","pear", "dog" };
+ var RoCS vl_badValues := { "house","apples" };
+ f_checkCharstringTemplate(tl_cs1,vl_goodValues,vl_badValues);
+}
+
+//=== cs2 ===
+testcase tc_CharstringTemplate2_eq() runs on A
+{
+ f_checkCharstringTemplateEquivalence(t_cs2,t_cs2_eq);
+}
+
+testcase tc_CharstringTemplate2_eq_local() runs on A
+{
+ template charstring tl_cs2 := ( "treeeeeeeeeeeeee",all from t_RoCS1, "dog", all from t_RoCS2);
+ f_checkCharstringTemplateEquivalence(tl_cs2,t_cs2_eq);
+}
+
+testcase tc_CharstringTemplate2_eq_dyn() runs on A
+{
+ var template charstring tl_cs2 := ( "treeeeeeeeeeeeee",all from t_RoCS1, "dog", all from t_RoCS2);
+ f_checkCharstringTemplateEquivalence(tl_cs2,t_cs2_eq);
+}
+
+testcase tc_CharstringTemplate2_eq_2dyn() runs on A
+{
+ var template RoCS tl_RoCS1 := { "apple","banana","","pear"};
+ var template RoCS tl_RoCS2 := { "apples","bananas","","pears"};
+ var template charstring tl_cs2 := ( "treeeeeeeeeeeeee",all from tl_RoCS1, "dog", all from tl_RoCS2);
+ f_checkCharstringTemplateEquivalence(tl_cs2,t_cs2_eq);
+}
+testcase tc_CharstringTemplate2() runs on A
+{
+ var RoCS vl_goodValues := { "apple","banana","","pear", "dog", "treeeeeeeeeeeeee","apples","bananas","pears" };
+ var RoCS vl_badValues := { "house","applesss","tree","a","app","appl","pple" };
+ f_checkCharstringTemplate(t_cs2,vl_goodValues,vl_badValues);
+}
+//=========================================================
+//================== Test for Octetstring =================
+//=========================================================
+
+//== 1 ===
+//( all from t_RoOS1 )
+//('ABBA'O,'BABA'O,'FFFF'O,'00'O,'0B'O)
+testcase tc_OctetstringTemplate1_eq() runs on A
+{
+ f_checkOctetstringTemplateEquivalence(t_os1,t_os1_eq);
+}
+
+testcase tc_OctetstringTemplate1() runs on A
+{
+
+ var RoOS vl_goodValues := { 'ABBA'O,'BABA'O,'FFFF'O,'00'O,'0B'O };
+ var RoOS vl_badValues := { ''O,'0000'O,'00FF'O,'AA'O,'00ABBA'O };
+ f_checkOctetstringTemplate(t_os1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_OctetstringTemplate1_eq_local() runs on A
+{
+ template octetstring tl_os1 := ( all from t_RoOS1 );
+ f_checkOctetstringTemplateEquivalence(tl_os1,t_os1_eq);
+}
+
+testcase tc_OctetstringTemplate1_eq_dyn() runs on A
+{
+ var template octetstring tl_os1 := ( all from t_RoOS1 );
+ f_checkOctetstringTemplateEquivalence(tl_os1,t_os1_eq);
+}
+
+testcase tc_OctetstringTemplate1_eq_local_dyn() runs on A
+{
+ template RoOS tl_RoOS1 := {'ABBA'O,'BABA'O,'FFFF'O,'00'O,'0B'O}
+ var template octetstring tl_os1 := ( all from tl_RoOS1 );
+ f_checkOctetstringTemplateEquivalence(tl_os1,t_os1_eq);
+}
+
+testcase tc_OctetstringTemplate1_eq_2dyn() runs on A
+{
+ var template RoOS tl_RoOS1 := {'ABBA'O,'BABA'O,'FFFF'O,'00'O,'0B'O}
+ var template octetstring tl_os1 := ( all from tl_RoOS1 );
+ f_checkOctetstringTemplateEquivalence(tl_os1,t_os1_eq);
+}
+
+testcase tc_OctetstringTemplate1_dyn() runs on A
+{
+ var RoOS vl_goodValues := { 'ABBA'O,'BABA'O,'FFFF'O,'00'O,'0B'O };
+ var RoOS vl_badValues := { ''O,'0000'O,'00FF'O,'AA'O,'00ABBA'O };
+ f_checkOctetstringTemplate(t_os1,vl_goodValues,vl_badValues);
+}
+//=========================================================
+//================== Test for Records =====================
+//=========================================================
+testcase tc_MyRecordTemplate1_eq() runs on A {
+ f_checkMyRecordTemplateEquivalence(t_myrec1,t_myrec1_eq);
+}
+
+testcase tc_MyRecordTemplate1() runs on A
+{
+ var RoMyRec vl_goodValues := {
+ {i:=1,roi:={1,2,6},soi:={1,7,2} },
+ {i:=2,roi:={1,2,7},soi:={1,9,2} } };
+ var RoMyRec vl_badValues := {{omit,omit,omit} };
+ f_checkMyRecTemplate(t_myrec1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_MyRecordTemplate2_eq() runs on A {
+ f_checkMyRecordTemplateEquivalence(t_myrec2,t_myrec2_eq);
+}
+
+testcase tc_MyRecordTemplate3_eq() runs on A {
+ f_checkMyRecordTemplateEquivalence(t_myrec3,t_myrec3_eq);
+}
+
+//=========================================================
+//================== Test for Union =====================
+//=========================================================
+testcase tc_MyUnionTemplate1i_eq() runs on A {
+ f_checkMyUnionTemplateEquivalence(t_myunion1i,t_myunion1i_eq);
+}
+
+testcase tc_MyUnionTemplate1i() runs on A
+{
+ var RoMyUnion vl_goodValues := {{i:=1},{i:=2},{i:=6},{i:=7},{i:=8},{i:=9},{i:=100}} ;
+ var RoMyUnion vl_badValues := {{i:=0},{i:=3},{roi:={}},{roi:={1,2}}};
+ f_checkMyUnionTemplate(t_myunion1i,vl_goodValues,vl_badValues);
+}
+testcase tc_MyUnionTemplate1roi() runs on A
+{
+ var RoMyUnion vl_goodValues := {
+ { roi:={1,2} },{roi:={1,2}},{roi:={1,6}},{roi:={2,7}},{roi:={100,100}} };
+ var RoMyUnion vl_badValues := {{roi:={1}},{roi:={1,4}}, {roi:={2,3}},{roi:={1,2,3}},{roi:={1,2,6,101}},{roi:={1,2,6,100}} };
+ f_checkMyUnionTemplate(t_myunion1roi,vl_goodValues,vl_badValues);
+}
+testcase tc_MyUnionTemplate1soi() runs on A
+{
+ var RoMyUnion vl_goodValues := {
+ { soi:={1,2} },{soi:={1,2}},{soi:={1,6}},{soi:={2,7}},{soi:={100,100}} };
+ var RoMyUnion vl_badValues := { {soi:={}},{soi:={1,3}},{soi:={1,101}} };
+ f_checkMyUnionTemplate(t_myunion1soi,vl_goodValues,vl_badValues);
+}
+testcase tc_MyUnionTemplate2i_eq() runs on A {
+ f_checkMyUnionTemplateEquivalence(t_myunion2i,t_myunion2i_eq);
+}
+testcase tc_MyUnionTemplate2roi_eq() runs on A {
+ f_checkMyUnionTemplateEquivalence(t_myunion2roi,t_myunion2roi_eq);
+}
+testcase tc_MyUnionTemplate2soi_eq() runs on A {
+ f_checkMyUnionTemplateEquivalence(t_myunion2soi,t_myunion2soi_eq);
+}
+testcase tc_MyUnionTemplate3_eq() runs on A {
+ f_checkMyUnionTemplateEquivalence(t_myunion3,t_myunion3_eq);
+}
+
+//==== function reference =====
+testcase tc_functionRef_rof_eq() runs on A {
+ f_checkMyFunctionRefTemplateEquivalence( t_fref_int2int,t_fref_int2int_eq);
+}
+
+// all from with length restriction
+// 1. the target of 'all from' is foldable (known at compile-time)
+testcase tc_varTemplate_len_res_foldable() runs on A
+{
+ template RoI tl_foldable := { 6, 9 };
+ var template RoI tl_len_res := { 2, all from tl_foldable } length (3);
+ var template RoI tl_len_res_eq := { 2, 6, 9 } length (3);
+ f_checkRoITemplateEquivalence(tl_len_res, tl_len_res_eq);
+}
+
+// 2. the target of 'all from' is unfoldable (not known at compile-time)
+testcase tc_varTemplate_len_res_unfoldable() runs on A
+{
+ var template RoI tl_unfoldable := { 6, 9 };
+ var template RoI tl_len_res := { 2, all from tl_unfoldable } length (3);
+ var template RoI tl_len_res_eq := { 2, 6, 9 } length (3);
+ f_checkRoITemplateEquivalence(tl_len_res, tl_len_res_eq);
+}
+
+// HU21359 Length of record of template containing 'all from' is invalid
+template RoI t_ints_1 := { 1 };
+template RoI t_ints_2 := { 2, 3 };
+
+function modify (template RoI p1, template RoI p2)
+return template RoI
+{
+ return { all from p1, all from p2 };
+}
+
+testcase tc_HU21359() runs on A {
+ var template RoI vt_res := modify(t_ints_1, t_ints_2);
+ var template RoI vt_exp := { 1, 2, 3 };
+ f_checkRoITemplateEquivalence(vt_res, vt_exp);
+}
+
+
+// control part is NOT used during the test!
+control {
+ // execute(tc_checkIntegerValueListTemplate_eq());
+execute(tc_checkIntegerValueListTemplate());
+execute(tc_checkIntegerValueListTemplate0_eq());
+execute(tc_checkImportingIntegerValueListTemplate0_eq());
+execute(tc_checkIntegerValueListTemplate0());
+execute(tc_checkImportingIntegerValueListTemplate0());
+execute(tc_checkIntegerValueListTemplate1_eq());
+execute(tc_checkImportingIntegerValueListTemplate1_eq());
+execute(tc_checkIntegerValueListTemplate1());
+execute(tc_checkImportingIntegerValueListTemplate1());
+execute(tc_checkIntegerValueListTemplate2_eq());
+execute(tc_checkImportingIntegerValueListTemplate2_eq());
+execute(tc_checkIntegerValueListTemplate2());
+execute(tc_checkImportingIntegerValueListTemplate2());
+execute(tc_checkIntegerValueListTemplate3_eq());
+execute(tc_checkIntegerValueListTemplate3());
+execute(tc_checkIntegerValueListTemplate4_eq());
+execute(tc_checkIntegerValueListTemplate4());
+execute(tc_checkIntegerValueListTemplate5_eq());
+execute(tc_checkIntegerValueListTemplate5());
+execute(tc_checkIntegerValueListTemplate6_eq());
+execute(tc_checkIntegerValueListTemplate6());
+execute(tc_checkIntegerValueListTemplate7_eq());
+execute(tc_checkIntegerValueListTemplate7());
+execute(tc_checkIntegerValueListTemplate8_eq());
+execute(tc_checkIntegerValueListTemplate8());
+execute(tc_checkIntegerValueListTemplate9_eq());
+execute(tc_checkIntegerValueListTemplate9());
+execute(tc_checkIntegerValueListTemplate13roi_eq());
+execute(tc_checkIntegerValueListTemplate13roi());
+execute(tc_checkIntegerValueListTemplate13soi_eq());
+execute(tc_checkIntegerValueListTemplate13soi());
+execute(tc_checkIntegerValueListTemplate13roi_c_eq());
+execute(tc_checkIntegerValueListTemplate13roi_c());
+execute(tc_checkIntegerValueListTemplate13soi_c_eq());
+execute(tc_checkIntegerValueListTemplate13soi_c());
+execute(tc_checkAllFromInFunctionCall_IntegerValueListInTemplate13roi_eq());
+execute(tc_checkAllFromInFunctionCall_IntegerValueListInOutTemplate13roi_eq());
+execute(tc_checkAllFromInFunctionCall_IntegerValueListInTemplate13soi_eq());
+execute(tc_checkAllFromInFunctionCall_IntegerValueListInOutTemplate13soi_eq());
+execute(tc_checkAllFromComponentVar_IntegerValueListTemplate13roi_eq());
+execute(tc_checkAllFromComponentVar_IntegerValueListTemplate13soi_eq());
+execute(tc_checkIntegerValueListTemplate0s_eq());
+execute(tc_checkImportingIntegerValueListTemplate0s_eq());
+execute(tc_checkIntegerValueListTemplate0s());
+execute(tc_checkImportingIntegerValueListTemplate0s());
+execute(tc_checkIntegerValueListTemplate1s_eq());
+execute(tc_checkImportingIntegerValueListTemplate1s_eq());
+execute(tc_checkIntegerValueListTemplate1s());
+execute(tc_checkIntegerValueListTemplate2s_eq());
+execute(tc_checkIntegerValueListTemplate2s());
+execute(tc_checkIntegerValueListTemplate3s_eq());
+execute(tc_checkIntegerValueListTemplate3s());
+execute(tc_checkIntegerValueListTemplate4s_eq());
+execute(tc_checkIntegerValueListTemplate4s());
+execute(tc_checkIntegerValueListTemplate5s_eq());
+execute(tc_checkIntegerValueListTemplate5s());
+execute(tc_checkIntegerValueListTemplate6s_eq());
+execute(tc_checkIntegerValueListTemplate6s());
+execute(tc_checkIntegerValueListTemplate0_eq_dyn());
+execute(tc_checkImportingIntegerValueListTemplate0_eq_dyn());
+execute(tc_checkIntegerValueListTemplate0_eq_2dyn());
+execute(tc_checkIntegerValueListTemplate0_dyn());
+execute(tc_checkImportingIntegerValueListTemplate0_dyn());
+execute(tc_checkIntegerValueListTemplate0_2dyn());
+execute(tc_checkIntegerValueListTemplate1_eq_dyn());
+execute(tc_checkIntegerValueListTemplate1_eq_2dyn());
+execute(tc_checkIntegerValueListTemplate1_dyn());
+execute(tc_checkIntegerValueListTemplate1_2dyn());
+execute(tc_checkIntegerValueListTemplate2_eq_dyn());
+execute(tc_checkIntegerValueListTemplate2_eq_2dyn());
+execute(tc_checkIntegerValueListTemplate2_dyn());
+execute(tc_checkIntegerValueListTemplate2_2dyn());
+execute(tc_checkIntegerValueListTemplate3_eq_dyn());
+execute(tc_checkIntegerValueListTemplate3_eq_2dyn());
+execute(tc_checkIntegerValueListTemplate3_dyn());
+execute(tc_checkIntegerValueListTemplate3_2dyn());
+execute(tc_checkIntegerValueListTemplate4_eq_dyn());
+execute(tc_checkIntegerValueListTemplate4_eq_2dyn());
+execute(tc_checkIntegerValueListTemplate4_dyn());
+execute(tc_checkIntegerValueListTemplate4_2dyn());
+execute(tc_checkIntegerValueListTemplate5_eq_dyn());
+execute(tc_checkIntegerValueListTemplate5_eq_2dyn());
+execute(tc_checkIntegerValueListTemplate5_dyn());
+execute(tc_checkIntegerValueListTemplate5_2dyn());
+execute(tc_checkIntegerValueListTemplate6_eq_dyn());
+execute(tc_checkIntegerValueListTemplate6_eq_2dyn());
+execute(tc_checkIntegerValueListTemplate6_dyn());
+execute(tc_checkIntegerValueListTemplate6_2dyn());
+execute(tc_checkIntegerValueListTemplate7_eq_dyn());
+execute(tc_checkIntegerValueListTemplate7_eq_2dyn());
+execute(tc_checkIntegerValueListTemplate7_dyn());
+execute(tc_checkIntegerValueListTemplate7_2dyn());
+execute(tc_checkIntegerValueListTemplate8_eq_dyn());
+execute(tc_checkIntegerValueListTemplate8_eq_2dyn());
+execute(tc_checkIntegerValueListTemplate8_dyn());
+execute(tc_checkIntegerValueListTemplate8_2dyn());
+execute(tc_checkIntegerValueListTemplate9_eq_dyn());
+execute(tc_checkIntegerValueListTemplate9_eq_2dyn());
+execute(tc_checkIntegerValueListTemplate9_dyn());
+execute(tc_checkIntegerValueListTemplate9_2dyn());
+execute(tc_RoITemplate10_eq());
+execute(tc_checkIntegerValueListTemplate10_eq());
+execute(tc_checkIntegerValueListTemplate10_eq_local());
+execute(tc_checkIntegerValueListTemplate10_eq_dyn());
+execute(tc_checkIntegerValueListTemplate10_eq_2dyn());
+execute(tc_checkIntegerValueListTemplate10_eq_3dyn());
+execute(tc_checkIntegerValueListTemplate10_eq_4dyn());
+execute(tc_checkIntegerValueListTemplate10_eq_5dyn());
+execute(tc_checkIntegerValueListTemplate10());
+execute(tc_checkIntegerValueListTemplate10_dyn());
+execute(tc_checkIntegerValueListTemplate10_loc_dyn());
+execute(tc_checkIntegerValueListTemplate10_2loc_2dyn());
+execute(tc_checkIntegerValueListTemplate10_3loc_2dyn());
+execute(tc_checkIntegerValueListTemplate10_1dyn_1loc_3dyn());
+execute(tc_checkIntegerValueListTemplate10_2loc_3dyn());
+execute(tc_checkIntegerValueListTemplate10_6dyn());
+execute(tc_checkIntegerValueListTemplate10_5dyn());
+execute(tc_checkIntegerValueListTemplate10_4dyn());
+execute(tc_checkIntegerValueListTemplate0s_eq_dyn());
+execute(tc_checkIntegerValueListTemplate0s_eq_2dyn());
+execute(tc_checkIntegerValueListTemplate0s_dyn());
+execute(tc_checkIntegerValueListTemplate0s_2dyn());
+execute(tc_checkIntegerValueListTemplate1s_eq_dyn());
+execute(tc_checkIntegerValueListTemplate1s_eq_2dyn());
+execute(tc_checkIntegerValueListTemplate1s_dyn());
+execute(tc_checkIntegerValueListTemplate1s_2dyn());
+execute(tc_CharstringTemplate1_eq());
+execute(tc_CharstringTemplate1_eq_local());
+execute(tc_CharstringTemplate1_eq_dyn());
+execute(tc_CharstringTemplate1_eq_2dyn());
+execute(tc_CharstringTemplate1());
+execute(tc_CharstringTemplate1_local());
+execute(tc_CharstringTemplate1_dyn());
+execute(tc_CharstringTemplate1_2dyn());
+execute(tc_CharstringTemplate2_eq());
+execute(tc_CharstringTemplate2_eq_local());
+execute(tc_CharstringTemplate2_eq_dyn());
+execute(tc_CharstringTemplate2_eq_2dyn());
+execute(tc_CharstringTemplate2());
+execute(tc_OctetstringTemplate1_eq());
+execute(tc_OctetstringTemplate1());
+execute(tc_OctetstringTemplate1_eq_local());
+execute(tc_OctetstringTemplate1_eq_dyn());
+execute(tc_OctetstringTemplate1_eq_local_dyn());
+execute(tc_OctetstringTemplate1_eq_2dyn());
+execute(tc_OctetstringTemplate1_dyn());
+execute(tc_MyRecordTemplate1_eq());
+execute(tc_MyRecordTemplate1());
+execute(tc_MyRecordTemplate2_eq());
+execute(tc_MyRecordTemplate3_eq());
+execute(tc_MyUnionTemplate1i_eq());
+execute(tc_MyUnionTemplate1i());
+execute(tc_MyUnionTemplate1roi());
+execute(tc_MyUnionTemplate1soi());
+execute(tc_MyUnionTemplate2i_eq());
+execute(tc_MyUnionTemplate2roi_eq());
+execute(tc_MyUnionTemplate2soi_eq());
+execute(tc_MyUnionTemplate3_eq());
+execute(tc_functionRef_rof_eq());
+execute(tc_varTemplate_len_res_foldable());
+execute(tc_varTemplate_len_res_unfoldable());
+execute(tc_HU21359());
+}
+
+}
diff --git a/Regression_Test_java/src/all_from/all_from_complement.ttcn b/Regression_Test_java/src/all_from/all_from_complement.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..983059a8be803c1157b33072c182af26e908d30f
--- /dev/null
+++ b/Regression_Test_java/src/all_from/all_from_complement.ttcn
@@ -0,0 +1,574 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module all_from_complement { // ETSI CR 6088
+import from types all;
+import from functions all;
+
+template RoI t_imported_RoI1 := {1, 2, (6..9)};
+template RoI t_imported_RoI2 := {1, *, 3};
+template RoI t_imported_RoI3 := {20,21,22};
+template RoI t_imported_RoI4 := {1, ?, 3};
+//for permutation:
+template RoI t_imported_RoI1_P := {1, 2, *};
+template RoI t_imported_RoI3_P := {1, 2, 3};
+template RoI t_imported_RoI7_P := {1, 2, ?};
+
+//===========Set of Integer================================
+template SoI t_imported_SoI1 := {1,2,(6..9)};
+template SoI t_imported_SoI2 := {1, *, 3};
+template SoI t_imported_SoI3 := {20,21,22};
+
+// B 1.2.1 Template List
+// "It can be used on values of all types"
+
+//just to test these types as well:
+modulepar RoI tsp_RoI3 := {20,21,22};
+modulepar RoI tsp_SoI3 := {20,21,22};
+
+const RoI c_RoI3 := {20,21,22};
+const SoI c_SoI3 := {20,21,22};
+
+//============Record of Integer============================
+template RoI t_RoI1 := {1, 2, (6..9)};
+template RoI t_RoI2 := {1, *, 3};
+template RoI t_RoI3 := {20,21,22};
+template RoI t_RoI4 := {1, ?, 3};
+
+//template RoI t_RoI1c := {complement (1),complement (2), complement(6)};
+
+template integer t_i0 := complement(all from t_RoI1);
+template integer t_i0_eq := complement (1, 2, (6..9));
+
+template integer t_i1 := complement(all from t_RoI1, 100);
+template integer t_i1_eq :=complement(1, 2, (6..9), 100);
+
+template integer t_i2 := complement (-1,0,all from t_RoI1, 100);
+template integer t_i2_eq := complement (-1,0,1, 2, (6..9), 100);
+
+template integer t_i3 := complement (-1,0,all from t_RoI1, all from t_RoI3, 100);
+template integer t_i3_eq := complement (-1,0,1, 2, (6..9),20,21,22, 100);
+
+template integer t_i4 := complement (-1,0,all from t_RoI1, 100, all from t_RoI3);
+template integer t_i4_eq := complement (-1,0,1, 2, (6..9),100,20,21,22 );
+
+template integer t_i5 := complement (-1,0,all from t_RoI1, 100, all from t_RoI3,all from t_RoI3 ); //repetition
+template integer t_i5_eq := complement (-1,0,1, 2, (6..9),100,20,21,22,20,21,22);
+
+template integer t_i6 := complement (-1,0,all from t_RoI1, 100, all from t_RoI3,all from t_RoI3,all from t_RoI3); //repetition
+template integer t_i6_eq := complement (-1,0, 1, 2, (6..9),100,20,21,22,20,21,22,20,21,22);
+//from modulepar:
+template integer t_i13roi := complement(all from tsp_RoI3);
+template integer t_i13_eq := complement(20,21,22);
+template integer t_i13soi := complement(all from tsp_SoI3);
+
+//from const:
+template integer t_i13roi_c := complement(all from c_RoI3);
+template integer t_i13soi_c := complement(all from c_SoI3);
+//=== All from referring remote templates (imported templates)
+template integer t_importing_i0 := complement(all from t_imported_RoI1);
+template integer t_importing_i1 := complement(all from t_imported_RoI1, 100);
+template integer t_importing_i2 := complement(-1,0,all from t_imported_RoI1, 100);
+template integer t_importing_i3 := complement(-1,0,all from t_imported_RoI1, all from t_imported_RoI3, 100);
+template integer t_importing_i4 := complement(-1,0,all from t_imported_RoI1, 100, all from t_imported_RoI3);
+template integer t_importing_i5 := complement(-1,0,all from t_imported_RoI1, 100,all from t_imported_RoI3,all from t_imported_RoI3 ); //repetition
+template integer t_importing_i6 := complement(-1,0,all from t_imported_RoI1, 100, all from t_imported_RoI3,all from t_imported_RoI3,all from t_imported_RoI3); //repetition
+template integer t_importing_i7 := complement(all from t_imported_RoI4,100);
+template integer t_importing_i8 := complement(100,all from t_imported_RoI4);
+template integer t_importing_i9 := complement(100,all from t_imported_RoI4,-1);
+//===========Set of Integer================================
+template SoI t_SoI1 := {1, 2, (6..9)};
+template SoI t_SoI2 := {1, *, 3};
+template SoI t_SoI3 := {20,21,22};
+
+template integer t_i0s := complement(all from t_SoI1);
+template integer t_i0s_eq := complement( 1,2,(6..9));
+
+template integer t_i1s := complement(all from t_SoI1, 100);
+template integer t_i1s_eq := complement( 1,2,(6..9),100);
+// equivalent to (1, 2, (6..9) , 100);
+
+template integer t_i2s := complement(-1,0,all from t_SoI1, 100);
+template integer t_i2s_eq := complement( -1,0,1,2,(6..9),100);
+
+template integer t_i3s := complement(-1,0,all from t_SoI1, all from t_SoI3, 100);
+template integer t_i3s_eq := complement( -1,0,1,2,(6..9),20,21,22,100);
+
+template integer t_i4s := complement(-1,0,all from t_SoI1, 100, all from t_SoI3);
+template integer t_i5s := complement(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3 ); //repetition
+template integer t_i6s := complement(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3,all from t_SoI3); //repetition
+
+//===========Record of of charstring================================
+template RoCS t_RoCS1 := { "apple","banana","","pear"};
+template RoCS t_RoCS2 := { "apples","bananas","","pears"};
+template charstring t_cs1 := complement ( all from t_RoCS1, "dog" );
+template charstring t_cs2 := complement ( "treeeeeeeeeeeeee",all from t_RoCS1, "dog", all from t_RoCS2);
+//==== function reference =====
+template RoF_int2int t_rofref_int2int := { refers(f_int2int_1),refers(f_int2int_2) }
+template F_int2int t_fref_int2int_c := complement( all from t_rofref_int2int );
+template F_int2int t_fref_int2int_c_eq := complement( refers(f_int2int_1),refers(f_int2int_2) );
+//============== Test for Integer List ================================
+
+//----- Tests for static templates ------
+
+//real static template, without any manipulation
+testcase tc_complementInt() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ action("t_i1=", t_i1, " will be checked against ",vl_goodValues);
+ var integer N:=sizeof(vl_goodValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (match(vl_goodValues[i], t_i1)) { setverdict(pass); }
+ else { setverdict(fail,vl_goodValues[i], " should match ", t_i1); }
+ }
+
+ var RoI vl_badValues := { 1,2,6,7,8,9,100};
+ action("t_i1=", t_i1, " will be checked against ",vl_badValues);
+ N:=sizeof(vl_badValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (not match(vl_badValues[i], t_i1)) { setverdict(pass); }
+ else { setverdict(fail,vl_badValues[i], " should match ", t_i1); }
+ }
+
+}
+//=== i0 ===
+//complement(1, 2, (6..9));
+testcase tc_complementInt0_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i0,t_i0_eq);
+}
+
+testcase tc_complementImportingInt0_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_importing_i0,t_i0_eq);
+}
+
+testcase tc_complementInt0() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := {1,2,6,7,8,9};
+ f_checkIntegerTemplate(t_i0,vl_goodValues,vl_badValues);
+}
+testcase tc_complementImportingInt0() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := {1,2,6,7,8,9};
+ f_checkIntegerTemplate(t_importing_i0,vl_goodValues,vl_badValues);
+}
+//=== i1 ===
+//complement(1, 2, (6..9), 100);
+testcase tc_complementInt1_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i1,t_i1_eq);
+}
+testcase tc_complementInt1() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { 1,2,6,7,8,9,100};
+ f_checkIntegerTemplate(t_i1,vl_goodValues,vl_badValues);
+}
+
+//complement (-1,0,1, 2, (6..9), 100);
+testcase tc_complementInt2_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i2,t_i2_eq);
+}
+testcase tc_complementInt2() runs on A
+{
+ var RoI vl_goodValues :={ -99,-10,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100};
+ f_checkIntegerTemplate(t_i2,vl_goodValues,vl_badValues);
+}
+
+//complement (-1,0,1, 2, (6..9),20,21,22, 100);
+testcase tc_complementInt3_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i3,t_i3_eq);
+}
+testcase tc_complementInt3() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ f_checkIntegerTemplate(t_i3,vl_goodValues,vl_badValues);
+}
+
+//order
+testcase tc_complementInt4_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i4,t_i4_eq);
+}
+testcase tc_complementInt4() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ f_checkIntegerTemplate(t_i4,vl_goodValues,vl_badValues);
+}
+//repetition
+
+testcase tc_complementInt5_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i5,t_i5_eq);
+}
+testcase tc_complementInt5() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ f_checkIntegerTemplate(t_i5,vl_goodValues,vl_badValues);
+}
+//=== i6 ===
+testcase tc_complementInt6_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i6,t_i6_eq);
+}
+testcase tc_complementInt6() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ f_checkIntegerTemplate(t_i6,vl_goodValues,vl_badValues);
+}
+//=== i13 ===
+//modulepar test
+
+testcase tc_complementInt13roi_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i13roi,t_i13_eq);
+}
+testcase tc_complementInt13roi() runs on A
+{
+ var RoI vl_goodValues := {-1,19,23,24,100};
+ var RoI vl_badValues := { 20,21,22};
+ f_checkIntegerTemplate(t_i13roi,vl_goodValues,vl_badValues);
+}
+testcase tc_complementInt13soi_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i13soi,t_i13_eq);
+}
+testcase tc_complementInt13soi() runs on A
+{
+ var RoI vl_goodValues := {-1,19,23,24,100};
+ var RoI vl_badValues := { 20,21,22};
+ f_checkIntegerTemplate(t_i13soi,vl_goodValues,vl_badValues);
+}
+
+//const test:
+testcase tc_complementInt13roi_c_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i13roi_c,t_i13_eq);
+}
+testcase tc_complementInt13roi_c() runs on A
+{
+ var RoI vl_goodValues := {-1,19,23,24,100};
+ var RoI vl_badValues := { 20,21,22};
+ f_checkIntegerTemplate(t_i13roi_c,vl_goodValues,vl_badValues);
+}
+testcase tc_complementInt13soi_c_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i13soi_c,t_i13_eq);
+}
+testcase tc_complementInt13soi_c() runs on A
+{
+ var RoI vl_goodValues := {-1,19,23,24,100};
+ var RoI vl_badValues := { 20,21,22};
+ f_checkIntegerTemplate(t_i13soi_c,vl_goodValues,vl_badValues);
+}
+//====== templates derived from set of integers
+
+//=== i0s ===
+//complement(1, 2, (6..9));
+testcase tc_complementInt0s_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i0s,t_i0s_eq);
+}
+
+testcase tc_complementInt0s() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := {1,2,6,7,8,9};
+ f_checkIntegerTemplate(t_i0s,vl_goodValues,vl_badValues);
+}
+//=== i1s ===
+testcase tc_complementInt1s_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i1s,t_i1s_eq);
+}
+
+testcase tc_complementInt1s() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { 1,2,6,7,8,9,100};
+ f_checkIntegerTemplate(t_i1s,vl_goodValues,vl_badValues);
+}
+//=== i2s ===
+testcase tc_complementInt2s_eq() runs on A{
+ f_checkIntTemplateEquivalence(t_i2s,t_i2s_eq);
+}
+testcase tc_complementInt2s() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100};
+ f_checkIntegerTemplate(t_i2s,vl_goodValues,vl_badValues);
+}
+//=== i3s ===
+testcase tc_complementInt3s() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ f_checkIntegerTemplate(t_i3s,vl_goodValues,vl_badValues);
+}
+//=== i4s ===
+//order
+testcase tc_complementInt4s() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ f_checkIntegerTemplate(t_i4s,vl_goodValues,vl_badValues);
+}
+
+//=== i5s ===
+//repetition
+testcase tc_complementInt5s() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ f_checkIntegerTemplate(t_i5s,vl_goodValues,vl_badValues);
+}
+//=== i6s ===
+testcase tc_complementInt6s() runs on A
+{
+ var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ f_checkIntegerTemplate(t_i6s,vl_goodValues,vl_badValues);
+}
+
+
+//-------- Tests for dynamic templates ( template variables) ----
+
+//=== i0 ===
+//complement(1, 2, (6..9));
+testcase tc_complementInt0_eq_dyn() runs on A{
+ var template integer tl_i0 := complement (all from t_RoI1);
+ f_checkIntTemplateEquivalence(tl_i0,t_i0_eq);
+}
+
+testcase tc_complementInt0_eq_2dyn() runs on A{
+ var template RoI tl_RoI1 := {1, 2, (6..9)};
+ var template integer tl_i0 := complement (all from tl_RoI1);
+ f_checkIntTemplateEquivalence(tl_i0,t_i0_eq);
+}
+
+testcase tc_complementInt0_dyn() runs on A
+{
+ var template integer tl_i0 := complement (all from t_RoI1);
+ var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := {1,2,6,7,8,9};
+ f_checkIntegerTemplate(tl_i0,vl_goodValues,vl_badValues);
+}
+
+testcase tc_complementInt0_2dyn() runs on A
+{
+ var template RoI tl_RoI1 := {1, 2, (6..9)};
+ var template integer tl_i0 := complement(all from tl_RoI1);
+ var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := {1,2,6,7,8,9};
+ f_checkIntegerTemplate(tl_i0,vl_goodValues,vl_badValues);
+}
+
+//=== i1 ===
+testcase tc_complementInt1_dyn() runs on A
+{
+ var template integer tl_i1 := complement (all from t_RoI1, 100);
+ var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { 1,2,6,7,8,9,100};
+ f_checkIntegerTemplate(tl_i1,vl_goodValues,vl_badValues);
+}
+testcase tc_complementInt1_2dyn() runs on A
+{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template integer tl_i1 := complement(all from tl_RoI1, 100);
+ var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := {1,2,6,7,8,9,100};
+ f_checkIntegerTemplate(tl_i1,vl_goodValues,vl_badValues);
+}
+
+//=== i2 ===
+testcase tc_complementInt2_dyn() runs on A
+{
+ var template integer tl_i2 := complement(-1,0,all from t_RoI1, 100);
+ var RoI vl_goodValues := { -99,-10,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100};
+ f_checkIntegerTemplate(tl_i2,vl_goodValues,vl_badValues);
+}
+
+testcase tc_complementInt2_2dyn() runs on A
+{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template integer tl_i2 := complement(-1,0,all from tl_RoI1, 100);
+ var RoI vl_goodValues := {-99,-10,3,4,5,10,11,20,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := {-1,0,1,2,6,7,8,9,100};
+ f_checkIntegerTemplate(tl_i2,vl_goodValues,vl_badValues);
+}
+
+//=== i3 ===
+testcase tc_complementInt3_dyn() runs on A
+{
+ var template integer tl_i4 := complement(-1,0,all from t_RoI1, 100, all from t_RoI3);
+ var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ f_checkIntegerTemplate(tl_i4,vl_goodValues,vl_badValues);
+}
+
+testcase tc_complementInt3_2dyn() runs on A
+{
+ var template RoI tl_RoI1:= {1, 2, (6..9)};
+ var template RoI tl_RoI3 := {20,21,22};
+ var template integer tl_i4 := complement(-1,0,all from tl_RoI1, 100, all from tl_RoI3);
+ var RoI vl_goodValues := { -99,-10,3,4,5,10,11,19,23,40,42,44,99,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := { -1,0,1,2,6,7,8,9,100,20,21,22};
+ f_checkIntegerTemplate(tl_i4,vl_goodValues,vl_badValues);
+}
+
+//=== i4 ===
+
+//======== Dyn. Set Of Int=========================
+
+//=== i0 ===
+//complement(1, 2, (6..9));
+testcase tc_complementInt0s_eq_dyn() runs on A{
+ var template integer tl_i0s := complement (all from t_SoI1);
+ f_checkIntTemplateEquivalence(tl_i0s,t_i0s_eq);
+}
+
+testcase tc_complementInt0s_eq_2dyn() runs on A{
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template integer tl_i0s := complement (all from tl_SoI1);
+ f_checkIntTemplateEquivalence(tl_i0s,t_i0s_eq);
+}
+
+testcase tc_complementInt0s_dyn() runs on A
+{
+ var template integer tl_i0s := complement (all from t_SoI1);
+ var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := {1,2,6,7,8,9};
+ f_checkIntegerTemplate(tl_i0s,vl_goodValues,vl_badValues);
+}
+
+testcase tc_complementInt0s_2dyn() runs on A
+{
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template integer tl_i0s := complement(all from tl_SoI1);
+ var RoI vl_goodValues := { -99,-10,-1,0,3,4,5,10,11,20,99,100,101,102,200,1000, 100000000000000};
+ var RoI vl_badValues := {1,2,6,7,8,9};
+ f_checkIntegerTemplate(t_i0s,vl_goodValues,vl_badValues);
+}
+
+//=== i1s ===
+
+//+++++++++ NEGATIVE TEST+++++++++++++++++++++++++
+// see: TTCN3_SA_13_TD.script
+
+//=========================================================
+//===== Test for Record of charstring =====================
+//=========================================================
+
+testcase tc_complementCharstring1() runs on A
+{
+ var RoCS vl_goodValues := { "house","apples" };
+ var RoCS vl_badValues := { "apple","banana","","pear", "dog" };
+ f_checkCharstringTemplate(t_cs1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_complementCharstring2() runs on A
+{
+ var RoCS vl_goodValues := { "house","applesss","tree","a","app","appl","pple" };
+ var RoCS vl_badValues := { "apple","banana","","pear", "dog", "treeeeeeeeeeeeee","apples","bananas","pears" };
+ f_checkCharstringTemplate(t_cs2,vl_goodValues,vl_badValues);
+}
+
+//=========================================================
+//================== Test for Records =====================
+//=========================================================
+//====== Embedded templates ====
+template MyRecord t_myrec1 := { i:= t_i1, roi:=t_RoI1, soi:=t_SoI1 }
+template MyRecord t_myrec1_eq := { i:= t_i1_eq, roi:=t_RoI1, soi:=t_SoI1 }
+
+template MyRecord t_myrec2 := { i:= t_i2, roi:=t_RoI1, soi:=t_SoI1 }
+template MyRecord t_myrec2_eq := { i:= t_i2_eq, roi:=t_RoI1, soi:=t_SoI1 }
+
+testcase tc_complementMyRec1_eq() runs on A {
+ f_checkMyRecordTemplateEquivalence(t_myrec1,t_myrec1_eq);
+}
+
+testcase tc_complementMyRec1() runs on A
+{
+ var RoMyRec vl_goodValues := {
+ {i:=3,roi:={1,2,6},soi:={1,7,2} },
+ {i:=0,roi:={1,2,7},soi:={1,9,2} } };
+ var RoMyRec vl_badValues := {{omit,omit,omit} };
+ f_checkMyRecTemplate(t_myrec1,vl_goodValues,vl_badValues);
+}
+
+testcase tc_complementMyRec2_eq() runs on A {
+ f_checkMyRecordTemplateEquivalence(t_myrec2,t_myrec2_eq);
+}
+
+//==== function reference =====
+testcase tc_functionRef_rof_c_eq() runs on A {
+ f_checkMyFunctionRefTemplateEquivalence( t_fref_int2int_c,t_fref_int2int_c_eq);
+}
+
+
+// control part is NOT used during the test!
+control {
+ // execute(tc_complementInt_eq());
+execute(tc_complementInt0_eq());
+execute(tc_complementImportingInt0_eq());
+execute(tc_complementInt0());
+execute(tc_complementImportingInt0());
+execute(tc_complementInt1_eq());
+execute(tc_complementInt1());
+execute(tc_complementInt2_eq());
+execute(tc_complementInt2());
+execute(tc_complementInt3_eq());
+execute(tc_complementInt3());
+execute(tc_complementInt4_eq());
+execute(tc_complementInt4());
+execute(tc_complementInt5_eq());
+execute(tc_complementInt5());
+execute(tc_complementInt6_eq());
+execute(tc_complementInt6());
+execute(tc_complementInt13roi_eq());
+execute(tc_complementInt13roi());
+execute(tc_complementInt13soi_eq());
+execute(tc_complementInt13soi());
+execute(tc_complementInt13roi_c_eq());
+execute(tc_complementInt13roi_c());
+execute(tc_complementInt13soi_c_eq());
+execute(tc_complementInt13soi_c());
+execute(tc_complementInt0s_eq());
+execute(tc_complementInt0s());
+execute(tc_complementInt1s_eq());
+execute(tc_complementInt1s());
+execute(tc_complementInt2s_eq());
+execute(tc_complementInt2s());
+execute(tc_complementInt3s());
+execute(tc_complementInt4s());
+execute(tc_complementInt5s());
+execute(tc_complementInt6s());
+execute(tc_complementInt0_eq_dyn());
+execute(tc_complementInt0_eq_2dyn());
+execute(tc_complementInt0_dyn());
+execute(tc_complementInt0_2dyn());
+execute(tc_complementInt1_dyn());
+execute(tc_complementInt1_2dyn());
+execute(tc_complementInt2_dyn());
+execute(tc_complementInt2_2dyn());
+execute(tc_complementInt3_dyn());
+execute(tc_complementInt3_2dyn());
+execute(tc_complementInt0s_eq_dyn());
+execute(tc_complementInt0s_eq_2dyn());
+execute(tc_complementInt0s_dyn());
+execute(tc_complementInt0s_2dyn());
+execute(tc_complementCharstring1());
+execute(tc_complementCharstring2());
+execute(tc_complementMyRec1_eq());
+execute(tc_complementMyRec1());
+execute(tc_complementMyRec2_eq());
+execute(tc_functionRef_rof_c_eq());
+}
+
+}
diff --git a/Regression_Test_java/src/all_from/all_from_permutation.ttcn b/Regression_Test_java/src/all_from/all_from_permutation.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..4aade0543e9e79a3185b74f726b1ec517992d902
--- /dev/null
+++ b/Regression_Test_java/src/all_from/all_from_permutation.ttcn
@@ -0,0 +1,1961 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ * Szabo, Bence Janos
+ *
+ ******************************************************************************/
+module all_from_permutation
+{
+import from types all;
+import from functions all;
+
+template RoI t_imported_RoI1 := {1, 2, (6..9)};
+template RoI t_imported_RoI2 := {1, *, 3};
+template RoI t_imported_RoI3 := {20,21,22};
+template RoI t_imported_RoI4 := {1, ?, 3};
+//for permutation:
+template RoI t_imported_RoI1_P := {1, 2, *};
+template RoI t_imported_RoI3_P := {1, 2, 3};
+template RoI t_imported_RoI7_P := {1, 2, ?};
+
+//===========Set of Integer================================
+template SoI t_imported_SoI1 := {1,2,(6..9)};
+template SoI t_imported_SoI2 := {1, *, 3};
+template SoI t_imported_SoI3 := {20,21,22};
+
+// Test Target:
+// B.1.3.3 Permutation
+//"That shall be used only on values of record types"
+
+//just to test these types as well:
+modulepar RoI tsp_RoI3 := {20,21,22};
+modulepar RoI tsp_SoI3 := {20,21,22};
+
+const RoI c_RoI3 := {20,21,22};
+const SoI c_SoI3 := {20,21,22};
+/*
+template RoI t_RoI1 := {1, 2, (6..9)};
+template RoI t_RoI2 := {1, *, 3};
+
+// B.1.3.3 Permutation
+//EXAMPLE 1:
+ type RoI MySequenceOfType;
+
+ template MySequenceOfType MyTemplate1p := { permutation ( 1, 2, 3 ), 5 };
+ // matches any of the following sequences of 4 integers: 1,2,3,5; 1,3,2,5; 2,1,3,5;
+ // 2,3,1,5; 3,1,2,5; or 3,2,1,5
+
+ template MySequenceOfType MyTemplate2p := { permutation ( 1, 2, ? ), 5 };
+ // matches any sequence of 4 integers that ends with 5 and contains 1 and 2 at least once in
+ // other positions
+
+ template MySequenceOfType MyTemplate3p := { permutation ( 1, 2, 3 ), * };
+ // matches any sequence of integers starting with 1,2,3; 1,3,2; 2,1,3; 2,3,1; 3,1,2 or 3,2,1
+
+ template MySequenceOfType MyTemplate4p := { *, permutation ( 1, 2, 3 )};
+ // matches any sequence of integers ending with 1,2,3; 1,3,2; 2,1,3; 2,3,1; 3,1,2 or 3,2,1
+
+ template MySequenceOfType MyTemplate5p := { *, permutation ( 1, 2, 3 ),* };
+ // matches any sequence of integers containing any of the following substrings at any position:
+ // 1,2,3; 1,3,2; 2,1,3; 2,3,1; 3,1,2 or 3,2,1
+
+ template MySequenceOfType MyTemplate6p := { permutation ( 1, 2, * ), 5 };
+ // matches any sequence of integers that ends with 5 and containing 1 and 2 at least once in
+ // other positions
+
+//error by Titan: Length restriction cannot be used in a template of type `integer'
+// template MySequenceOfType MyTemplate7p := { permutation ( 1, 2, 3 ), * length (0..5) };
+ // matches any sequence of three to eight integers starting with 1,2,3; 1,3,2; 2,1,3; 2,3,1;
+ // 3,1,2 or 3,2,1
+
+ template integer MyInt1 := (1,2,3);
+ template integer MyInt2 := (1,2,?);
+ template integer MyInt3 := ?;
+ template integer MyInt4 := *;
+
+ template MySequenceOfType MyTemplate10 := { permutation (MyInt1, 2, 3 ), 5 };
+ // matches any of the sequences of 4 integers:
+ // 1,3,2,5; 2,1,3,5; 2,3,1,5; 3,1,2,5; or 3,2,1,5;
+ // 2,3,2,5; 2,2,3,5; 2,3,2,5; 3,2,2,5; or 3,2,2,5;
+ // 3,3,2,5; 2,3,3,5; 2,3,3,5; 3,3,2,5; or 3,2,3,5;
+
+ template MySequenceOfType MyTemplate11 := { permutation (MyInt2, 2, 3 ), 5 };
+ // matches any sequence of 4 integers that ends with 5 and contains 2 and 3 at least once in
+ // other positions
+
+ template MySequenceOfType MyTemplate12 := { permutation (MyInt3, 2, 3 ), 5 };
+ // matches any sequence of 4 integers that ends with 5 and contains 2 and 3 at least once in
+ // other positions
+
+ template MySequenceOfType MyTemplate13 := { permutation (MyInt4, 2, 3 ), 5 };
+ // matches any sequence of integers that ends with 5 and containing 2 and 3 at least once in
+ // other positions
+
+ template MySequenceOfType MyTemplate14 := { permutation (MyInt3, 2, ? ), 5 };
+ // matches any sequence of 4 integers that ends with 5 and contains 2 at least once in
+ // other positions
+
+ template MySequenceOfType MyTemplate15 := { permutation (MyInt4, 2, * ), 5 };
+ // matches any sequence of integers that ends with 5 and contains 2 at least once in
+ // other positions
+*/
+//EXAMPLE 2:
+template RoI t_RoI1 := {1, 2, *};
+template RoI t_RoI1p := {permutation(all from t_RoI1)};
+template RoI t_RoI1p_eq:={permutation(1, 2, *)};
+
+template RoI t_RoI2p := {permutation(0, all from t_RoI1), 4, 5};
+template RoI t_RoI2p_eq := {permutation(0,1,2,*), 4, 5};
+
+template RoI t_RoI3 := {1, 2, 3};
+template RoI t_RoI3p := {permutation( all from t_RoI3)};
+template RoI t_RoI3p_eq := {permutation(1, 2, 3)};
+
+template RoI t_RoI4p := {?,permutation(0, all from t_RoI1), 4, 5};
+template RoI t_RoI4p_eq := {?,permutation(0,1,2,*), 4, 5};
+
+template RoI t_RoI5p := {*,permutation(all from t_RoI3),*}
+template RoI t_RoI5p_eq := {*,permutation(1,2,3),*}
+
+template RoI t_RoI6p := {?,permutation(all from t_RoI3),4} //(?,permutation(1,2,3),4)
+template RoI t_RoI6p_eq := {?,permutation(1,2,3),4}
+
+template RoI t_RoI7 := {1, 2, ?};
+template RoI t_RoI7p := {permutation(all from t_RoI7)};
+template RoI t_RoI7p_eq := {permutation(1, 2, ?)};
+
+template RoI t_RoI8p := {permutation(0, all from t_RoI7), 4, 5};
+template RoI t_RoI8p_eq := {permutation(0,1,2,?), 4, 5};
+
+//from modulepar:
+template RoI t_RoI13roi := {permutation(all from tsp_RoI3)};
+template RoI t_RoI13_eq := {permutation(20,21,22)};
+template RoI t_RoI13soi := {permutation(all from tsp_SoI3)};
+
+//from const:
+template RoI t_RoI13roi_c :={permutation(all from c_RoI3)};
+template RoI t_RoI13soi_c :={permutation(all from c_SoI3)};
+
+//=== All from referring remote templates (imported templates)
+template RoI t_importing_RoI1p := {permutation(all from t_imported_RoI1_P)};
+template RoI t_importing_RoI2p := {permutation(0, all from t_imported_RoI1_P), 4, 5};
+template RoI t_importing_RoI3p := {permutation( all from t_imported_RoI3_P)};
+
+// ===== Set of ====
+template SoI t_SoI1 := {1, 2, *};
+template RoI t_SoI1p := {permutation(all from t_SoI1)};
+template RoI t_SoI1p_eq:={permutation(1, 2, *)};
+
+template RoI t_SoI2p := {permutation(0, all from t_SoI1), 4, 5};
+template RoI t_SoI2p_eq := {permutation(0,1,2,*), 4, 5};
+
+template SoI t_SoI3 := {1, 2, 3};
+template RoI t_SoI3p := {permutation( all from t_SoI3)};
+template RoI t_SoI3p_eq := {permutation(1, 2, 3)};
+
+template RoI t_SoI4p := {?,permutation(0, all from t_SoI1), 4, 5};
+template RoI t_SoI4p_eq := {?,permutation(0,1,2,*), 4, 5};
+
+template RoI t_SoI5p := {*,permutation(all from t_SoI3),*}
+template RoI t_SoI5p_eq := {*,permutation(1,2,3),*}
+
+template RoI t_SoI6p := {?,permutation(all from t_SoI3),4} //(?,permutation(1,2,3),4)
+template RoI t_SoI6p_eq := {?,permutation(1,2,3),4}
+
+template SoI t_SoI7 := {1, 2, ?};
+template RoI t_SoI7p := {permutation(all from t_SoI7)};
+template RoI t_SoI7p_eq := {permutation(1, 2, ?)};
+
+template RoI t_SoI8p := {permutation(0, all from t_SoI7), 4, 5};
+template RoI t_SoI8p_eq := {permutation(0,1,2,?), 4, 5};
+
+//===== charstring
+template RoCS t_RoCS1 := { "apple","banana","","pear"};
+template RoCS t_RoCS2 := { "apples","bananas","","pears"};
+
+template RoCS t_rocs1 := { permutation ( all from t_RoCS1 ) };
+template RoCS t_rocs1_eq := { permutation ( "apple","banana","","pear" ) };
+
+template RoCS t_rocs2 := { permutation( "treeeeeeeeeeeeee",all from t_RoCS1, "dog", all from t_RoCS2) };
+template RoCS t_rocs2_eq := { permutation( "treeeeeeeeeeeeee","apple","banana","","pear",
+ "dog","apples","bananas","","pears") };
+
+//==== function reference =====
+template RoF_int2int t_rofref_int2int := { refers(f_int2int_1),refers(f_int2int_2) }
+template RoF_int2int t_fref_int2int_p := { permutation( all from t_rofref_int2int ) };
+template RoF_int2int t_fref_int2int_p_eq := { permutation( refers(f_int2int_1),refers(f_int2int_2) ) };
+//************************* Testcases for Templates of type Record of Integer ******************************
+
+testcase tc_permut() runs on A
+{
+ action("permut: ", t_RoI2p);
+ var RoI v;
+
+ v := {}
+ if (not match(v, t_RoI2p)) { setverdict(pass); }
+ else { setverdict(fail, v, " should NOT match ", t_RoI2p); }
+
+ v := { 1 }
+ if (not match(v, t_RoI2p)) { setverdict(pass); }
+ else { setverdict(fail, v, " should NOT match ", t_RoI2p); }
+
+ v := { 1, 2, 3, 4, 5 }
+ if (not match(v, t_RoI2p)) { setverdict(pass); }
+ else { setverdict(fail, v, " should NOT match ", t_RoI2p); }
+
+ v := { 0, 1, 2, 3, 4, 5 }
+ if (match(v, t_RoI2p)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_RoI2p); }
+
+ v := { -2, -1, 0, 1, 2, 3, 4, 5 }
+ if (match(v, t_RoI2p)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_RoI2p); }
+
+ v := { 1, 2, 3, 0, 4, 5 }
+ if (match(v, t_RoI2p)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_RoI2p); }
+
+ v := { 1, 2, 3, 4, 5, 0 }
+ if (not match(v, t_RoI2p)) { setverdict(pass); }
+ else { setverdict(fail, v, " should NOT match ", t_RoI2p); }
+
+ v := { 5, 4, 3, 2, 1, 0 }
+ if (not match(v, t_RoI2p)) { setverdict(pass); }
+ else { setverdict(fail, v, " should NOT match ", t_RoI2p); }
+
+ v := { 3, 2, 1, 0, -1, -2, -3, 4, 5 }
+ if (match(v, t_RoI2p)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_RoI2p); }
+
+ v := { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4 }
+ if (not match(v, t_RoI2p)) { setverdict(pass); }
+ else { setverdict(fail, v, " should NOT match ", t_RoI2p); }
+
+ v := { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 4, 5 }
+ if (match(v, t_RoI2p)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_RoI2p); }
+}
+
+//====== Static Templates ======
+
+//=== 1 ===
+
+testcase tc_permut1_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_RoI1p,t_RoI1p_eq);
+}
+
+testcase tc_permutImporting1_eq() runs on A {
+ f_checkRoITemplateEquivalence( t_importing_RoI1p,t_RoI1p_eq);
+}
+
+testcase tc_permut1() runs on A {
+ var RoRoI vl_goodValues := {{1,2},{2,1},{1,2,0},{1,2,1,2,3,4},{2,1,0},{2,1,222},{1,1,1,2,2,2,2} }
+ var RoRoI vl_badValues := {{},{1},{2},{3},{3,4,5},{3,4,5,1},{3,4,5,2}
+ }
+ f_checkRoITemplate(t_RoI1p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permutImporting1() runs on A {
+ var RoRoI vl_goodValues := {{1,2},{2,1},{1,2,0},{1,2,1,2,3,4},{2,1,0},{2,1,222},{1,1,1,2,2,2,2} }
+ var RoRoI vl_badValues := {{},{1},{2},{3},{3,4,5},{3,4,5,1},{3,4,5,2}
+ }
+ f_checkRoITemplate(t_importing_RoI1p,vl_goodValues,vl_badValues);
+}
+//=== 2 ===
+//{permutation(0,1,2,*), 4, 5};
+testcase tc_permut2_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_RoI2p,t_RoI2p_eq);
+}
+
+testcase tc_permutImporting2_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_RoI2p,t_RoI2p_eq);
+}
+
+testcase tc_permut2() runs on A {
+ var RoRoI vl_goodValues := {
+ {0,1,2,4,5},{0,2,1,4,5},{1,0,2,4,5},{2,1,0,4,5},{1,2,0,4,5},
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ { -2, -1, 0, 1, 2, 3, 4, 5 },
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 4, 5 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4,5 }
+ };
+ var RoRoI vl_badValues := { {},{1},{1,2},{1,2,3},{1,2,3,4},{1,2,3,4,5},{0,1,2,3,4,6},{ 5, 4, 3, 2, 1, 0 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4 }};
+ f_checkRoITemplate(t_RoI2p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permutImporting2() runs on A {
+ var RoRoI vl_goodValues := {
+ {0,1,2,4,5},{0,2,1,4,5},{1,0,2,4,5},{2,1,0,4,5},{1,2,0,4,5},
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ { -2, -1, 0, 1, 2, 3, 4, 5 },
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 4, 5 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4,5 }
+ };
+ var RoRoI vl_badValues := { {},{1},{1,2},{1,2,3},{1,2,3,4},{1,2,3,4,5},{0,1,2,3,4,6},{ 5, 4, 3, 2, 1, 0 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4 }};
+ f_checkRoITemplate(t_importing_RoI2p,vl_goodValues,vl_badValues);
+}
+//=== 3 ===
+testcase tc_permut3_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_RoI3p,t_RoI3p_eq);
+}
+
+testcase tc_permutImporting3_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_importing_RoI3p,t_RoI3p_eq);
+}
+
+testcase tc_permut3() runs on A {
+ var RoRoI vl_goodValues := {
+ { 1,2,3},{1,3,2},
+ { 2,1,3},{2,3,1},
+ { 3,1,2},{3,2,1}
+ }
+ var RoRoI vl_badValues := { {},{1},{2},{3},{4},{1,2},{1,3},{1,4},{2,3},{1,2,3,4}, {1,2,3,3},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000}
+ }
+ f_checkRoITemplate(t_RoI3p,vl_goodValues,vl_badValues);
+}
+
+
+//=== 4 ===
+
+testcase tc_permut4_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_RoI4p,t_RoI4p_eq);
+}
+
+testcase tc_permut4() runs on A {
+ var RoRoI vl_goodValues := {
+ {99,0,1,2,3,4,5}, {99,0,1,3,2,4,5},{99,0,2,1,3,4,5},{99,0,2,3,1,4,5},{99,0,3,2,1,4,5},{99,0,3,1,2,4,5},
+ {99,1,0,2,3,4,5}, {99,1,0,3,2,4,5},{99,1,2,0,3,4,5},{99,1,2,3,0,4,5},{99,1,3,2,0,4,5},{99,1,3,0,2,4,5},
+ {99,2,1,0,3,4,5}, {99,2,1,3,0,4,5},{99,2,0,1,3,4,5},{99,2,0,3,1,4,5},{99,2,3,0,1,4,5},{99,2,3,1,0,4,5},
+ {99,3,1,0,2,4,5}, {99,3,1,2,0,4,5},{99,3,0,1,2,4,5},{99,3,0,2,1,4,5},{99,3,2,0,1,4,5},{99,3,2,1,0,4,5},
+ {99,0,1,2,9,4,5}, {99,0,1,9,2,4,5},{99,0,2,1,9,4,5},{99,0,2,9,1,4,5},{99,0,9,2,1,4,5},{99,0,9,1,2,4,5},
+ {99,1,0,2,9,4,5}, {99,1,0,9,2,4,5},{99,1,2,0,9,4,5},{99,1,2,9,0,4,5},{99,1,9,2,0,4,5},{99,1,9,0,2,4,5},
+ {99,2,1,0,9,4,5}, {99,2,1,9,0,4,5},{99,2,0,1,9,4,5},{99,2,0,9,1,4,5},{99,2,9,0,1,4,5},{99,2,9,1,0,4,5},
+ {99,9,1,0,2,4,5}, {99,9,1,2,0,4,5},{99,9,0,1,2,4,5},{99,9,0,2,1,4,5},{99,9,2,0,1,4,5},{99,9,2,1,0,4,5},
+ {99,9,1,9,0,2,4,5},
+ {99,9,1,2,9,0,4,5},{99,9,0,9,1,9,2,9,4,5},{99,9,0,2,1,4,5},{99,9,2,0,1,4,5},{99,9,2,1,0,4,5}
+ };
+ var RoRoI vl_badValues := { {},{1},{1,2},{1,2,3},{1,2,3,4},
+ {1,2,3,4,5}, {0,1,2,3,4,5},{0,1,2,3,5,4},{0,1,2,3,4,6},{ 5, 4, 3, 2, 1, 0 },{1,1,1,1,1,1}};
+ f_checkRoITemplate(t_RoI4p,vl_goodValues,vl_badValues);
+}
+
+
+//=== 5 ===
+//{*,permutation(1,2,3),*}
+testcase tc_permut5_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_RoI5p,t_RoI5p_eq);
+}
+
+testcase tc_permut5() runs on A {
+ var RoRoI vl_goodValues := {
+ { 1,2,3},{1,3,2},
+ { 0,2,1,3},{2,3,1},
+ { 3,1,2},{ 3,2,1},
+ {-200,200,0,1,2,3,-1000},{-200,200,0,1,3,2,-1000},
+ {-200,200,0,2,1,3,-1000},{-200,200,0,2,3,1,-1000},
+ {-200,200,0,3,1,2,-1000},{-200,200,0,3,2,1,-1000},
+ {1,-200,200,0,1,2,3,-1000},{1,-200,200,0,1,3,2,-1000},
+ {2,-200,200,0,2,1,3,-1000,2},{1,2,-200,200,0,2,3,1,-1000,2,1},
+ {-200,200,0,3,1,2,-1000},{-200,200,0,3,2,1,-1000}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(t_RoI5p,vl_goodValues,vl_badValues);
+}
+//=== 6 ===
+//{?,permutation(1,2,3),4}
+testcase tc_permut6_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_RoI6p,t_RoI6p_eq);
+}
+
+testcase tc_permut6() runs on A {
+ var RoRoI vl_goodValues := {
+ { 0,1,2,3,4},{0,1,3,2,4},
+ { 0,2,1,3,4},{0,2,3,1,4},
+ { 0,3,1,2,4},{0,3,2,1,4},
+
+ { 9,1,2,3,4},{9,1,3,2,4},
+ { 9,2,1,3,4},{9,2,3,1,4},
+ { 9,3,1,2,4},{9,3,2,1,4},
+
+ {5,1,2,3,4},{5,1,3,2,4},
+ {5,2,1,3,4},{5,2,3,1,4},
+ {5,3,1,2,4},{5,3,2,1,4},
+
+ {99,1,2,3,4},{-5,1,3,2,4},
+ {1,2,1,3,4},{2,2,3,1,4},
+ {3,3,1,2,4},{4,3,2,1,4}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ { 1,2,3},{1,3,2},
+ { 0,2,1,3},{0,2,3,1},
+ { 3,1,2},{ 3,2,1},
+
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(t_RoI6p,vl_goodValues,vl_badValues);
+}
+//=== 7 ===
+//{permutation{1, 2, ?}};
+testcase tc_permut7_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_RoI7p,t_RoI7p_eq);
+}
+
+testcase tc_permut7() runs on A {
+ var RoRoI vl_goodValues := {
+ {1,2,3}, {1,2,4},{1,2,5},{1,2,1000},
+ {1,3,2},{1,4,2},{1,5,2},{1,6,2},
+ {2,1,3},{2,1,4},{2,1,5},{2,1,6},
+ {3,1,2},{3,2,1},{4,1,2},{4,2,1},
+ {1000,1,2},{1,1000,2}
+ }
+ var RoRoI vl_badValues := { {},{1},{2},{3},{9999},{1,2},{2,1}, {13,31},
+ { 0,2,1,3},{0,2,3,1},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(t_RoI7p,vl_goodValues,vl_badValues);
+}
+
+//=== 8 ===
+//{permutation(0,1,2,?),4,5}
+
+testcase tc_permut8_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_RoI8p,t_RoI8p_eq);
+}
+
+testcase tc_permut8() runs on A {
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ {0,1,2,9,4,5}, {0,1,9,2,4,5},{0,2,1,9,4,5},{0,2,9,1,4,5},{0,9,2,1,4,5},{0,9,1,2,4,5},
+ {1,0,2,9,4,5}, {1,0,9,2,4,5},{1,2,0,9,4,5},{1,2,9,0,4,5},{1,9,2,0,4,5},{1,9,0,2,4,5},
+ {2,1,0,9,4,5}, {2,1,9,0,4,5},{2,0,1,9,4,5},{2,0,9,1,4,5},{2,9,0,1,4,5},{2,9,1,0,4,5},
+ {9,1,0,2,4,5}, {9,1,2,0,4,5},{9,0,1,2,4,5},{9,0,2,1,4,5},{9,2,0,1,4,5},{9,2,1,0,4,5}
+ }
+ var RoRoI vl_badValues := { {},{1},{1,2},{9,1,9,0,2,4,5}, {9,1,2,9,0,4,5},{9,0,9,1,9,2,9,4,5}
+
+ }
+ f_checkRoITemplate(t_RoI8p,vl_goodValues,vl_badValues);
+}
+//=== 13 ===
+//{permutation(0,1,2,?),4,5}
+
+testcase tc_permut13roi_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_RoI13roi,t_RoI13_eq);
+}
+
+testcase tc_permut13roi() runs on A {
+ var RoRoI vl_goodValues := {
+ {20,21,22},{20,22,21}
+ }
+ var RoRoI vl_badValues := { {},{1},{21},{21,22}, {20,21},{20,20,20}
+
+ }
+ f_checkRoITemplate(t_RoI13roi,vl_goodValues,vl_badValues);
+}
+testcase tc_permut13soi_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_RoI13soi,t_RoI13_eq);
+}
+
+testcase tc_permut13soi() runs on A {
+ var RoRoI vl_goodValues := {
+ {20,21,22},{20,22,21}
+ }
+ var RoRoI vl_badValues := { {},{1},{21},{21,22}, {20,21},{20,20,20}
+
+ }
+ f_checkRoITemplate(t_RoI13soi,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut13roi_c_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_RoI13roi_c,t_RoI13_eq);
+}
+
+testcase tc_permut13roi_c() runs on A {
+ var RoRoI vl_goodValues := {
+ {20,21,22},{20,22,21}
+ }
+ var RoRoI vl_badValues := { {},{1},{21},{21,22}, {20,21},{20,20,20}
+
+ }
+ f_checkRoITemplate(t_RoI13roi_c,vl_goodValues,vl_badValues);
+}
+testcase tc_permut13soi_c_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_RoI13soi_c,t_RoI13_eq);
+}
+
+testcase tc_permut13soi_c() runs on A {
+ var RoRoI vl_goodValues := {
+ {20,21,22},{20,22,21}
+ }
+ var RoRoI vl_badValues := { {},{1},{21},{21,22}, {20,21},{20,20,20}
+
+ }
+ f_checkRoITemplate(t_RoI13soi_c,vl_goodValues,vl_badValues);
+}
+
+//=== Testcases for Dynamic Templates=====
+
+
+//===1===
+//{permutation(1, 2, *)};
+
+testcase tc_permut1_eq_dyn() runs on A {
+ var template RoI tl_RoI1p := {permutation(all from t_RoI1)};
+ f_checkRoITemplateEquivalence(tl_RoI1p,t_RoI1p_eq);
+}
+
+testcase tc_permut1_eq_2dyn() runs on A {
+ var template RoI tl_RoI1 := {1, 2, *};
+ var template RoI tl_RoI1p := {permutation(all from tl_RoI1)};
+ f_checkRoITemplateEquivalence(tl_RoI1p,t_RoI1p_eq);
+}
+
+testcase tc_permut1_dyn() runs on A {
+ var template RoI tl_RoI1p := {permutation(all from t_RoI1)};
+ var RoRoI vl_goodValues := {{1,2},{2,1},{1,2,0},{1,2,1,2,3,4},{2,1,0},{2,1,222},{1,1,1,2,2,2,2} }
+ var RoRoI vl_badValues := {{},{1},{2},{3},{3,4,5},{3,4,5,1},{3,4,5,2}
+ }
+ f_checkRoITemplate(tl_RoI1p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut1_2dyn() runs on A {
+ var template RoI tl_RoI1 := {1, 2, *};
+ var template RoI tl_RoI1p := {permutation(all from tl_RoI1)};
+ var RoRoI vl_goodValues := {{1,2},{2,1},{1,2,0},{1,2,1,2,3,4},{2,1,0},{2,1,222},{1,1,1,2,2,2,2} }
+ var RoRoI vl_badValues := {{},{1},{2},{3},{3,4,5},{3,4,5,1},{3,4,5,2}
+ }
+ f_checkRoITemplate(tl_RoI1p,vl_goodValues,vl_badValues);
+}
+//=== 2 ===
+testcase tc_permut2_eq_dyn() runs on A {
+ var template RoI tl_RoI2p := {permutation(0, all from t_RoI1), 4, 5};
+ f_checkRoITemplateEquivalence(tl_RoI2p,t_RoI2p_eq);
+}
+
+testcase tc_permut2_eq_2dyn() runs on A {
+ var template RoI tl_RoI1 := {1, 2, *};
+ var template RoI tl_RoI2p := {permutation(0, all from tl_RoI1), 4, 5};
+ f_checkRoITemplateEquivalence(tl_RoI2p,t_RoI2p_eq);
+}
+
+testcase tc_permut2_dyn() runs on A {
+ var template RoI tl_RoI2p := {permutation(0, all from t_RoI1), 4, 5};
+ var RoRoI vl_goodValues := {
+ {0,1,2,4,5},{0,2,1,4,5},{1,0,2,4,5},{2,1,0,4,5},{1,2,0,4,5},
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ { -2, -1, 0, 1, 2, 3, 4, 5 },
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 4, 5 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4,5 }
+ };
+ var RoRoI vl_badValues := { {},{1},{1,2},{1,2,3},{1,2,3,4},{1,2,3,4,5},{0,1,2,3,4,6},{ 5, 4, 3, 2, 1, 0 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4 }};
+ f_checkRoITemplate(tl_RoI2p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut2_2dyn() runs on A {
+ var template RoI tl_RoI1 := {1, 2, *};
+ log("debug1");
+ var template RoI tl_RoI2p := {permutation(0, all from tl_RoI1), 4, 5};
+ log("debug2");
+ var RoRoI vl_goodValues := {
+ {0,1,2,4,5},{0,2,1,4,5},{1,0,2,4,5},{2,1,0,4,5},{1,2,0,4,5},
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ { -2, -1, 0, 1, 2, 3, 4, 5 },
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 4, 5 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4,5 }
+ };
+ var RoRoI vl_badValues := { {},{1},{1,2},{1,2,3},{1,2,3,4},{1,2,3,4,5},{0,1,2,3,4,6},{ 5, 4, 3, 2, 1, 0 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4 }};
+ f_checkRoITemplate(tl_RoI2p,vl_goodValues,vl_badValues);
+}
+
+//=== 3 ===
+testcase tc_permut3_eq_dyn() runs on A {
+ var template RoI tl_RoI3p := {permutation(all from t_RoI3)}
+ f_checkRoITemplateEquivalence(tl_RoI3p,t_RoI3p_eq);
+}
+
+testcase tc_permut3_eq_2dyn() runs on A {
+ var template RoI tl_RoI3 := {1, 2, 3};
+ var template RoI tl_RoI3p := {permutation(all from tl_RoI3)}
+ f_checkRoITemplateEquivalence(tl_RoI3p,t_RoI3p_eq);
+}
+
+testcase tc_permut3_dyn() runs on A {
+ log("debug1");
+ var template RoI tl_RoI3p := {permutation(all from t_RoI3)}
+ log("debug2");
+ var RoRoI vl_goodValues := {
+ { 1,2,3},{1,3,2},
+ { 2,1,3},{2,3,1},
+ { 3,1,2},{3,2,1}
+ }
+ var RoRoI vl_badValues := { {},{1},{2},{3},{4},{1,2},{1,3},{1,4},{2,3},{1,2,3,4},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000}
+ }
+ f_checkRoITemplate(tl_RoI3p,vl_goodValues,vl_badValues);
+}
+testcase tc_permut3_2dyn() runs on A {
+ var template RoI tl_RoI3 := {1, 2, 3};
+ log("debug1");
+ template RoI tl_RoI3p := {permutation(all from tl_RoI3)}
+ log("debug2");
+ var RoRoI vl_goodValues := {
+ { 1,2,3},{1,3,2},
+ { 2,1,3},{2,3,1},
+ { 3,1,2},{3,2,1}
+ }
+ var RoRoI vl_badValues := { {},{1},{2},{3},{4},{1,2},{1,3},{1,4},{2,3},{1,2,3,4},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000}
+ }
+ f_checkRoITemplate(tl_RoI3p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut3A_dyn() runs on A {
+ var integer x:=1,y:=2,z:=3;
+ var template RoI tl_RoI3 := {x, y, z};
+ log("debug1");
+ //template RoI tl_RoI5p_dyn := {*,permutation(all from tl_RoI3p_dyn),*}
+ template RoI tl_RoI3p := {permutation(all from tl_RoI3)}
+ log("debug2");
+ var RoRoI vl_goodValues := {
+ { 1,2,3},{1,3,2 },
+ { 2,1,3},{2,3,1},
+ { 3,1,2},{3,2,1}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI3p,vl_goodValues,vl_badValues);
+}
+//=== 4 ===
+testcase tc_permut4_eq_dyn() runs on A {
+ var template RoI tl_RoI4p := {?,permutation(0, all from t_RoI1), 4, 5};
+ f_checkRoITemplateEquivalence(tl_RoI4p,t_RoI4p_eq);
+}
+
+testcase tc_permut4_eq_2dyn() runs on A {
+ var template RoI tl_RoI1 := {1, 2, *};
+ var template RoI tl_RoI4p := {?,permutation(0, all from tl_RoI1), 4, 5};
+ f_checkRoITemplateEquivalence(tl_RoI4p,t_RoI4p_eq);
+}
+
+
+testcase tc_permut4_dyn() runs on A {
+ var template RoI tl_RoI4p := {permutation(0, all from t_RoI1), 4, 5}; //executor doesn't accept
+ var RoRoI vl_goodValues := {
+ {99,0,1,2,3,4,5}, {99,0,1,3,2,4,5},{99,0,2,1,3,4,5},{99,0,2,3,1,4,5},{99,0,3,2,1,4,5},{99,0,3,1,2,4,5},
+ {99,1,0,2,3,4,5}, {99,1,0,3,2,4,5},{99,1,2,0,3,4,5},{99,1,2,3,0,4,5},{99,1,3,2,0,4,5},{99,1,3,0,2,4,5},
+ {99,2,1,0,3,4,5}, {99,2,1,3,0,4,5},{99,2,0,1,3,4,5},{99,2,0,3,1,4,5},{99,2,3,0,1,4,5},{99,2,3,1,0,4,5},
+ {99,3,1,0,2,4,5}, {99,3,1,2,0,4,5},{99,3,0,1,2,4,5},{99,3,0,2,1,4,5},{99,3,2,0,1,4,5},{99,3,2,1,0,4,5},
+ {99,0,1,2,9,4,5}, {99,0,1,9,2,4,5},{99,0,2,1,9,4,5},{99,0,2,9,1,4,5},{99,0,9,2,1,4,5},{99,0,9,1,2,4,5},
+ {99,1,0,2,9,4,5}, {99,1,0,9,2,4,5},{99,1,2,0,9,4,5},{99,1,2,9,0,4,5},{99,1,9,2,0,4,5},{99,1,9,0,2,4,5},
+ {99,2,1,0,9,4,5}, {99,2,1,9,0,4,5},{99,2,0,1,9,4,5},{99,2,0,9,1,4,5},{99,2,9,0,1,4,5},{99,2,9,1,0,4,5},
+ {99,9,1,0,2,4,5}, {99,9,1,2,0,4,5},{99,9,0,1,2,4,5},{99,9,0,2,1,4,5},{99,9,2,0,1,4,5},{99,9,2,1,0,4,5},
+ {99,9,1,9,0,2,4,5}, {99,9,1,2,9,0,4,5},{99,9,0,9,1,9,2,9,4,5},{99,9,0,2,1,4,5},{99,9,2,0,1,4,5},{99,9,2,1,0,4,5}
+ };
+ var RoRoI vl_badValues := { {},{1},{1,2},{1,2,3},{1,2,3,4},{1,2,3,4,5},{0,1,2,3,5,4},{0,1,2,3,4,6},{ 5, 4, 3, 2, 1, 0 },{1,1,1,1,1,1}};
+ f_checkRoITemplate(tl_RoI4p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut4_2dyn() runs on A {
+ var template RoI tl_RoI1 := {1, 2, *};
+ var template RoI tl_RoI4p := {permutation(0, all from tl_RoI1), 4, 5}; //executor doesn't accept
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ {0,1,2,9,4,5}, {0,1,9,2,4,5},{0,2,1,9,4,5},{0,2,9,1,4,5},{0,9,2,1,4,5},{0,9,1,2,4,5},
+ {1,0,2,9,4,5}, {1,0,9,2,4,5},{1,2,0,9,4,5},{1,2,9,0,4,5},{1,9,2,0,4,5},{1,9,0,2,4,5},
+ {2,1,0,9,4,5}, {2,1,9,0,4,5},{2,0,1,9,4,5},{2,0,9,1,4,5},{2,9,0,1,4,5},{2,9,1,0,4,5},
+ {9,1,0,2,4,5}, {9,1,2,0,4,5},{9,0,1,2,4,5},{9,0,2,1,4,5},{9,2,0,1,4,5},{9,2,1,0,4,5},
+ {9,1,9,0,2,4,5}, {9,1,2,9,0,4,5},{9,0,9,1,9,2,9,4,5},{9,0,2,1,4,5},{9,2,0,1,4,5},{9,2,1,0,4,5}
+ };
+ var RoRoI vl_badValues := { {},{1},{1,2},{1,2,3},{1,2,3,4},{1,2,3,4,5},{0,1,2,3,5,4},{0,1,2,3,4,6},{ 5, 4, 3, 2, 1, 0 },{1,1,1,1,1,1}};
+ f_checkRoITemplate(tl_RoI4p,vl_goodValues,vl_badValues);
+}
+
+//=== 5 ===
+
+//{*,permutation(1,2,3),*}
+testcase tc_permut5_eq_dyn() runs on A {
+ var template RoI tl_RoI5p := {*,permutation(all from t_RoI3),*}
+ f_checkRoITemplateEquivalence(tl_RoI5p,t_RoI5p_eq);
+}
+
+testcase tc_permut5_eq_2dyn() runs on A {
+ var template RoI tl_RoI3 := {1, 2, 3};
+ var template RoI tl_RoI5p := {*,permutation(all from tl_RoI3),*}
+ f_checkRoITemplateEquivalence(tl_RoI5p,t_RoI5p_eq);
+}
+
+testcase tc_permut5_dyn() runs on A {
+ var template RoI tl_RoI5p := {*,permutation(all from t_RoI3),*}
+ var RoRoI vl_goodValues := {
+ {1,2,3},{1,3,2},
+ {2,1,3},{2,3,1},
+ {3,1,2},{3,2,1},
+ {0,2,1,3},{0,2,1,3,0},
+ {-200,200,0,1,2,3,-1000},{-200,200,0,1,3,2,-1000},
+ {-200,200,0,2,1,3,-1000},{-200,200,0,2,3,1,-1000},
+ {-200,200,0,3,1,2,-1000},{-200,200,0,3,2,1,-1000},
+ {1,-200,200,0,1,2,3,-1000},{1,-200,200,0,1,3,2,-1000},
+ {2,-200,200,0,2,1,3,-1000,2},{1,2,-200,200,0,2,3,1,-1000,2,1},
+ {-200,200,0,3,1,2,-1000},{-200,200,0,3,2,1,-1000}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI5p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut5_2dyn() runs on A {
+ var template RoI tl_RoI3 := {1, 2, 3};
+ var template RoI tl_RoI5p := {*,permutation(all from tl_RoI3),*}
+ var RoRoI vl_goodValues := {
+ { 1,2,3},{1,3,2},
+ { 2,1,3},{2,3,1},
+ { 3,1,2},{ 3,2,1},
+ {0,2,1,3},{0,2,1,3,0},
+ {-200,200,0,1,2,3,-1000},{-200,200,0,1,3,2,-1000},
+ {-200,200,0,2,1,3,-1000},{-200,200,0,2,3,1,-1000},
+ {-200,200,0,3,1,2,-1000},{-200,200,0,3,2,1,-1000},
+ {1,-200,200,0,1,2,3,-1000},{1,-200,200,0,1,3,2,-1000},
+ {2,-200,200,0,2,1,3,-1000,2},{1,2,-200,200,0,2,3,1,-1000,2,1},
+ {-200,200,0,3,1,2,-1000},{-200,200,0,3,2,1,-1000}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI5p,vl_goodValues,vl_badValues);
+}
+//=== 6 ===
+//{?,permutation(1,2,3),4}
+testcase tc_permut6_eq_dyn() runs on A {
+ var template RoI tl_RoI6p := {?,permutation(all from t_RoI3),4};
+ f_checkRoITemplateEquivalence(tl_RoI6p,t_RoI6p_eq);
+}
+
+testcase tc_permut6_eq_2dyn() runs on A {
+ var template RoI tl_RoI3 := {1, 2, 3};
+ var template RoI tl_RoI6p := {?,permutation(all from tl_RoI3),4};
+ f_checkRoITemplateEquivalence(tl_RoI6p,t_RoI6p_eq);
+}
+
+testcase tc_permut6_dyn() runs on A {
+ var template RoI tl_RoI6p := {?,permutation(all from t_RoI3),4} //(?,permutation(1,2,3),4)
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4},{0,1,3,2,4},
+ {0,2,1,3,4},{0,2,3,1,4},
+ {0,3,1,2,4},{0,3,2,1,4},
+ {1,1,2,3,4},{1,1,3,2,4},
+ {1,2,1,3,4},{1,2,3,1,4},
+ {1,3,1,2,4},{1,3,2,1,4},
+ {2,1,2,3,4},{2,1,3,2,4},
+ {2,2,1,3,4},{2,2,3,1,4},
+ {2,3,1,2,4},{2,3,2,1,4},
+ {3,1,2,3,4},{3,1,3,2,4},
+ {3,2,1,3,4},{3,2,3,1,4},
+ {3,3,1,2,4},{3,3,2,1,4},
+
+ {9,1,2,3,4},{9,1,3,2,4},
+ {9,2,1,3,4},{9,2,3,1,4},
+ {9,3,1,2,4},{9,3,2,1,4},
+
+ {5,1,2,3,4},{5,1,3,2,4},
+ {5,2,1,3,4},{5,2,3,1,4},
+ {5,3,1,2,4},{5,3,2,1,4},
+
+ {99,1,2,3,4},{-5,1,3,2,4},
+ {1,2,1,3,4},{2,2,3,1,4},
+ {3,3,1,2,4},{4,3,2,1,4}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ {1,2,3},{1,3,2},
+ {0,2,1,3},{0,2,3,1},
+ {3,1,2},{3,2,1},
+
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI6p,vl_goodValues,vl_badValues);
+}
+testcase tc_permut6_2dyn() runs on A {
+ var template RoI tl_RoI3 := {1, 2, 3};
+ var template RoI tl_RoI6p := {?,permutation(all from tl_RoI3),4};
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4},{0,1,3,2,4},
+ {0,2,1,3,4},{0,2,3,1,4},
+ {0,3,1,2,4},{0,3,2,1,4},
+
+ {1,1,2,3,4},{1,1,3,2,4},
+ {1,2,1,3,4},{1,2,3,1,4},
+ {1,3,1,2,4},{1,3,2,1,4},
+ {2,1,2,3,4},{2,1,3,2,4},
+ {2,2,1,3,4},{2,2,3,1,4},
+ {2,3,1,2,4},{2,3,2,1,4},
+ {3,1,2,3,4},{3,1,3,2,4},
+ {3,2,1,3,4},{3,2,3,1,4},
+ {3,3,1,2,4},{3,3,2,1,4},
+
+ {9,1,2,3,4},{9,1,3,2,4},
+ {9,2,1,3,4},{9,2,3,1,4},
+ {9,3,1,2,4},{9,3,2,1,4},
+
+ {5,1,2,3,4},{5,1,3,2,4},
+ {5,2,1,3,4},{5,2,3,1,4},
+ {5,3,1,2,4},{5,3,2,1,4},
+
+ {99,1,2,3,4},{-5,1,3,2,4},
+ {1,2,1,3,4},{2,2,3,1,4},
+ {3,3,1,2,4},{4,3,2,1,4}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ { 1,2,3},{1,3,2},
+ { 0,2,1,3},{0,2,3,1},
+ { 3,1,2},{ 3,2,1},
+
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI6p,vl_goodValues,vl_badValues);
+}
+testcase tc_permut6A_dyn() runs on A {
+ var integer x:=1,y:=2,z:=3;
+ var template RoI tl_RoI3 := {x, y, z};
+ var template RoI tl_RoI6p := {?,permutation(all from tl_RoI3),4}
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4},{0,1,3,2,4},
+ {0,2,1,3,4},{0,2,3,1,4},
+ {0,3,1,2,4},{0,3,2,1,4},
+ {1,1,2,3,4},{1,1,3,2,4},
+ {1,2,1,3,4},{1,2,3,1,4},
+ {1,3,1,2,4},{1,3,2,1,4},
+ {2,1,2,3,4},{2,1,3,2,4},
+ {2,2,1,3,4},{2,2,3,1,4},
+ {2,3,1,2,4},{2,3,2,1,4},
+ {3,1,2,3,4},{3,1,3,2,4},
+ {3,2,1,3,4},{3,2,3,1,4},
+ {3,3,1,2,4},{3,3,2,1,4},
+ {9,1,2,3,4},{9,1,3,2,4},
+ {9,2,1,3,4},{9,2,3,1,4},
+ {9,3,1,2,4},{9,3,2,1,4},
+
+ {5,1,2,3,4},{5,1,3,2,4},
+ {5,2,1,3,4},{5,2,3,1,4},
+ {5,3,1,2,4},{5,3,2,1,4},
+
+ {99,1,2,3,4},{-5,1,3,2,4},
+ {1,2,1,3,4},{2,2,3,1,4},
+ {3,3,1,2,4},{4,3,2,1,4}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ { 1,2,3},{1,3,2},
+ { 2,1,3},{2,3,1},
+ { 3,1,2},{ 3,2,1},
+ { 0,1,2,3},{1,1,3,2},
+ { 2,2,1,3},{3,2,3,1},
+ { 4,3,1,2},{5,3,2,1},
+ { 1,2,3,4},{1,3,2,4},
+ { 2,1,3,4},{2,3,1,4},
+ { 3,1,2,4},{ 3,2,1,4},
+ { 0,1,2,3,5},{1,1,3,2,6},
+ { 2,2,1,3,7},{3,2,3,1,8},
+ { 4,3,1,2,9},{5,3,2,1,10},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI6p,vl_goodValues,vl_badValues);
+}
+
+//=== 7 ===
+//{permutation{1, 2, ?}};
+testcase tc_permut7_eq_dyn() runs on A {
+ var template RoI tl_RoI7p := {permutation(all from t_RoI7)};
+ f_checkRoITemplateEquivalence(tl_RoI7p,t_RoI7p_eq);
+}
+
+testcase tc_permut7_eq_2dyn() runs on A {
+ var template RoI tl_RoI7 := {1, 2, ?};
+ var template RoI tl_RoI7p := {permutation(all from tl_RoI7)};
+ f_checkRoITemplateEquivalence(tl_RoI7p,t_RoI7p_eq);
+}
+
+testcase tc_permut7_dyn() runs on A {
+ var template RoI tl_RoI7p := {permutation(all from t_RoI7)};
+ var RoRoI vl_goodValues := {
+ {1,2,3},{1,2,4},{1,2,5},{1,2,1000},
+ {1,3,2},{1,4,2},{1,5,2},{1,6,2},
+ {2,1,3},{2,1,4},{2,1,5},{2,1,6},
+ {3,1,2},{3,2,1},{4,1,2},{4,2,1},
+ {1000,1,2},{1,1000,2}
+ }
+ var RoRoI vl_badValues := { {},{1},{2},{3},{9999},{1,2},{2,1}, {13,31},
+ { 0,2,1,3},{0,2,3,1},{0,2,3,1,5},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI7p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut7_2dyn() runs on A {
+ var template RoI tl_RoI7 := {1, 2, ?};
+ var template RoI tl_RoI7p := {permutation(all from tl_RoI7)};
+ var RoRoI vl_goodValues := {
+ {1,2,3}, {1,2,4},{1,2,5},{1,2,1000},
+ {1,3,2},{1,4,2},{1,5,2},{1,6,2},
+ {2,1,3},{2,1,4},{2,1,5},{2,1,6},
+ {3,1,2},{3,2,1},{4,1,2},{4,2,1},
+ {1000,1,2},{1,1000,2}
+ }
+ var RoRoI vl_badValues := { {},{1},{2},{3},{9999},{1,2},{2,1}, {13,31},
+ { 0,2,1,3},{0,2,3,1},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI7p,vl_goodValues,vl_badValues);
+}
+
+//=== 8 ===
+//{permutation(0,1,2,?),4,5}
+
+testcase tc_permut8_eq_dyn() runs on A {
+ var template RoI tl_RoI8p := {permutation(0, all from t_RoI7), 4, 5};
+ f_checkRoITemplateEquivalence(tl_RoI8p,t_RoI8p_eq);
+}
+
+testcase tc_permut8_eq_2dyn() runs on A {
+ var template RoI tl_RoI7 := {1, 2, ?};
+ var template RoI tl_RoI8p := {permutation(0, all from tl_RoI7), 4, 5};
+ f_checkRoITemplateEquivalence(tl_RoI8p,t_RoI8p_eq);
+}
+
+testcase tc_permut8_dyn() runs on A {
+ var template RoI tl_RoI8p := {permutation(0, all from t_RoI7), 4, 5};
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ {0,1,2,9,4,5}, {0,1,9,2,4,5},{0,2,1,9,4,5},{0,2,9,1,4,5},{0,9,2,1,4,5},{0,9,1,2,4,5},
+ {1,0,2,9,4,5}, {1,0,9,2,4,5},{1,2,0,9,4,5},{1,2,9,0,4,5},{1,9,2,0,4,5},{1,9,0,2,4,5},
+ {2,1,0,9,4,5}, {2,1,9,0,4,5},{2,0,1,9,4,5},{2,0,9,1,4,5},{2,9,0,1,4,5},{2,9,1,0,4,5},
+ {9,1,0,2,4,5}, {9,1,2,0,4,5},{9,0,1,2,4,5},{9,0,2,1,4,5},{9,2,0,1,4,5},{9,2,1,0,4,5}
+ }
+ var RoRoI vl_badValues := { {},{1},{1,2},{9,1,9,0,2,4,5}, {9,1,2,9,0,4,5},{9,0,9,1,9,2,9,4,5}
+
+ }
+ f_checkRoITemplate(tl_RoI8p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut8_2dyn() runs on A {
+ var template RoI tl_RoI7 := {1, 2, ?};
+ var template RoI tl_RoI8p := {permutation(0, all from tl_RoI7), 4, 5};
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ {0,1,2,9,4,5}, {0,1,9,2,4,5},{0,2,1,9,4,5},{0,2,9,1,4,5},{0,9,2,1,4,5},{0,9,1,2,4,5},
+ {1,0,2,9,4,5}, {1,0,9,2,4,5},{1,2,0,9,4,5},{1,2,9,0,4,5},{1,9,2,0,4,5},{1,9,0,2,4,5},
+ {2,1,0,9,4,5}, {2,1,9,0,4,5},{2,0,1,9,4,5},{2,0,9,1,4,5},{2,9,0,1,4,5},{2,9,1,0,4,5},
+ {9,1,0,2,4,5}, {9,1,2,0,4,5},{9,0,1,2,4,5},{9,0,2,1,4,5},{9,2,0,1,4,5},{9,2,1,0,4,5}
+ }
+ var RoRoI vl_badValues := { {},{1},{1,2},{9,1,9,0,2,4,5}, {9,1,2,9,0,4,5},{9,0,9,1,9,2,9,4,5}
+
+ }
+ f_checkRoITemplate(tl_RoI8p,vl_goodValues,vl_badValues);
+}
+
+//====================================================
+// ===== Permutation test for all from SoI ===========
+//====================================================
+
+
+//====== Static Templates ======
+
+//=== 1 ===
+
+testcase tc_permut1s_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_SoI1p,t_SoI1p_eq);
+}
+
+testcase tc_permut1s() runs on A {
+ var RoRoI vl_goodValues := {{1,2},{2,1},{1,2,0},{1,2,1,2,3,4},{2,1,0},{2,1,222},{1,1,1,2,2,2,2} }
+ var RoRoI vl_badValues := {{},{1},{2},{3},{3,4,5},{3,4,5,1},{3,4,5,2}
+ }
+ f_checkRoITemplate(t_SoI1p,vl_goodValues,vl_badValues);
+}
+
+//=== 2 ===
+//{permutation(0,1,2,*), 4, 5};
+testcase tc_permut2s_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_SoI2p,t_SoI2p_eq);
+}
+
+testcase tc_permut2s() runs on A {
+ var RoRoI vl_goodValues := {
+ {0,1,2,4,5},{0,2,1,4,5},{1,0,2,4,5},{2,1,0,4,5},{1,2,0,4,5},
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ { -2, -1, 0, 1, 2, 3, 4, 5 },
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 4, 5 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4,5 }
+ };
+ var RoRoI vl_badValues := { {},{1},{1,2},{1,2,3},{1,2,3,4},{1,2,3,4,5},{0,1,2,3,4,6},{ 5, 4, 3, 2, 1, 0 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4 }};
+ f_checkRoITemplate(t_SoI2p,vl_goodValues,vl_badValues);
+}
+
+//=== 3 ===
+testcase tc_permut3s_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_SoI3p,t_SoI3p_eq);
+}
+
+testcase tc_permut3s() runs on A {
+ var RoRoI vl_goodValues := {
+ { 1,2,3},{1,3,2},
+ { 2,1,3},{2,3,1},
+ { 3,1,2},{3,2,1}
+ }
+ var RoRoI vl_badValues := { {},{1},{2},{3},{4},{1,2},{1,3},{1,4},{2,3},{1,2,3,4}, {1,2,3,3},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000}
+ }
+ f_checkRoITemplate(t_SoI3p,vl_goodValues,vl_badValues);
+}
+
+
+//=== 4 ===
+
+testcase tc_permut4s_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_SoI4p,t_SoI4p_eq);
+}
+
+testcase tc_permut4s() runs on A {
+ var RoRoI vl_goodValues := {
+ {99,0,1,2,3,4,5}, {99,0,1,3,2,4,5},{99,0,2,1,3,4,5},{99,0,2,3,1,4,5},{99,0,3,2,1,4,5},{99,0,3,1,2,4,5},
+ {99,1,0,2,3,4,5}, {99,1,0,3,2,4,5},{99,1,2,0,3,4,5},{99,1,2,3,0,4,5},{99,1,3,2,0,4,5},{99,1,3,0,2,4,5},
+ {99,2,1,0,3,4,5}, {99,2,1,3,0,4,5},{99,2,0,1,3,4,5},{99,2,0,3,1,4,5},{99,2,3,0,1,4,5},{99,2,3,1,0,4,5},
+ {99,3,1,0,2,4,5}, {99,3,1,2,0,4,5},{99,3,0,1,2,4,5},{99,3,0,2,1,4,5},{99,3,2,0,1,4,5},{99,3,2,1,0,4,5},
+ {99,0,1,2,9,4,5}, {99,0,1,9,2,4,5},{99,0,2,1,9,4,5},{99,0,2,9,1,4,5},{99,0,9,2,1,4,5},{99,0,9,1,2,4,5},
+ {99,1,0,2,9,4,5}, {99,1,0,9,2,4,5},{99,1,2,0,9,4,5},{99,1,2,9,0,4,5},{99,1,9,2,0,4,5},{99,1,9,0,2,4,5},
+ {99,2,1,0,9,4,5}, {99,2,1,9,0,4,5},{99,2,0,1,9,4,5},{99,2,0,9,1,4,5},{99,2,9,0,1,4,5},{99,2,9,1,0,4,5},
+ {99,9,1,0,2,4,5}, {99,9,1,2,0,4,5},{99,9,0,1,2,4,5},{99,9,0,2,1,4,5},{99,9,2,0,1,4,5},{99,9,2,1,0,4,5},
+ {99,9,1,9,0,2,4,5},
+ {99,9,1,2,9,0,4,5},{99,9,0,9,1,9,2,9,4,5},{99,9,0,2,1,4,5},{99,9,2,0,1,4,5},{99,9,2,1,0,4,5}
+ };
+ var RoRoI vl_badValues := { {},{1},{1,2},{1,2,3},{1,2,3,4},
+ {1,2,3,4,5}, {0,1,2,3,4,5},{0,1,2,3,5,4},{0,1,2,3,4,6},{ 5, 4, 3, 2, 1, 0 },{1,1,1,1,1,1}};
+ f_checkRoITemplate(t_SoI4p,vl_goodValues,vl_badValues);
+}
+
+
+//=== 5 ===
+//{*,permutation(1,2,3),*}
+testcase tc_permut5s_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_SoI5p,t_SoI5p_eq);
+}
+
+testcase tc_permut5s() runs on A {
+ var RoRoI vl_goodValues := {
+ { 1,2,3},{1,3,2},
+ { 0,2,1,3},{2,3,1},
+ { 3,1,2},{ 3,2,1},
+ {-200,200,0,1,2,3,-1000},{-200,200,0,1,3,2,-1000},
+ {-200,200,0,2,1,3,-1000},{-200,200,0,2,3,1,-1000},
+ {-200,200,0,3,1,2,-1000},{-200,200,0,3,2,1,-1000},
+ {1,-200,200,0,1,2,3,-1000},{1,-200,200,0,1,3,2,-1000},
+ {2,-200,200,0,2,1,3,-1000,2},{1,2,-200,200,0,2,3,1,-1000,2,1},
+ {-200,200,0,3,1,2,-1000},{-200,200,0,3,2,1,-1000}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(t_SoI5p,vl_goodValues,vl_badValues);
+}
+//=== 6 ===
+//{?,permutation(1,2,3),4}
+testcase tc_permut6s_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_SoI6p,t_SoI6p_eq);
+}
+
+testcase tc_permut6s() runs on A {
+ var RoRoI vl_goodValues := {
+ { 0,1,2,3,4},{0,1,3,2,4},
+ { 0,2,1,3,4},{0,2,3,1,4},
+ { 0,3,1,2,4},{0,3,2,1,4},
+
+ { 9,1,2,3,4},{9,1,3,2,4},
+ { 9,2,1,3,4},{9,2,3,1,4},
+ { 9,3,1,2,4},{9,3,2,1,4},
+
+ {5,1,2,3,4},{5,1,3,2,4},
+ {5,2,1,3,4},{5,2,3,1,4},
+ {5,3,1,2,4},{5,3,2,1,4},
+
+ {99,1,2,3,4},{-5,1,3,2,4},
+ {1,2,1,3,4},{2,2,3,1,4},
+ {3,3,1,2,4},{4,3,2,1,4}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ { 1,2,3},{1,3,2},
+ { 0,2,1,3},{0,2,3,1},
+ { 3,1,2},{ 3,2,1},
+
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(t_SoI6p,vl_goodValues,vl_badValues);
+}
+//=== 7 ===
+//{permutation{1, 2, ?}};
+testcase tc_permut7s_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_SoI7p,t_SoI7p_eq);
+}
+
+testcase tc_permut7s() runs on A {
+ var RoRoI vl_goodValues := {
+ {1,2,3}, {1,2,4},{1,2,5},{1,2,1000},
+ {1,3,2},{1,4,2},{1,5,2},{1,6,2},
+ {2,1,3},{2,1,4},{2,1,5},{2,1,6},
+ {3,1,2},{3,2,1},{4,1,2},{4,2,1},
+ {1000,1,2},{1,1000,2}
+ }
+ var RoRoI vl_badValues := { {},{1},{2},{3},{9999},{1,2},{2,1}, {13,31},
+ { 0,2,1,3},{0,2,3,1},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(t_SoI7p,vl_goodValues,vl_badValues);
+}
+
+//=== 8 ===
+//{permutation(0,1,2,?),4,5}
+
+testcase tc_permut8s_eq() runs on A {
+ f_checkRoITemplateEquivalence(t_SoI8p,t_SoI8p_eq);
+}
+
+testcase tc_permut8s() runs on A {
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ {0,1,2,9,4,5}, {0,1,9,2,4,5},{0,2,1,9,4,5},{0,2,9,1,4,5},{0,9,2,1,4,5},{0,9,1,2,4,5},
+ {1,0,2,9,4,5}, {1,0,9,2,4,5},{1,2,0,9,4,5},{1,2,9,0,4,5},{1,9,2,0,4,5},{1,9,0,2,4,5},
+ {2,1,0,9,4,5}, {2,1,9,0,4,5},{2,0,1,9,4,5},{2,0,9,1,4,5},{2,9,0,1,4,5},{2,9,1,0,4,5},
+ {9,1,0,2,4,5}, {9,1,2,0,4,5},{9,0,1,2,4,5},{9,0,2,1,4,5},{9,2,0,1,4,5},{9,2,1,0,4,5}
+ }
+ var RoRoI vl_badValues := { {},{1},{1,2},{9,1,9,0,2,4,5}, {9,1,2,9,0,4,5},{9,0,9,1,9,2,9,4,5}
+
+ }
+ f_checkRoITemplate(t_SoI8p,vl_goodValues,vl_badValues);
+}
+
+
+//=== Testcases for Dynamic Templates of type RoI created from SoI =====
+
+
+//===1===
+//{permutation(1, 2, *)};
+
+testcase tc_permut1s_eq_dyn() runs on A {
+ var template RoI tl_RoI1p := {permutation(all from t_SoI1)};
+ f_checkRoITemplateEquivalence(tl_RoI1p,t_SoI1p_eq);
+}
+
+testcase tc_permut1s_eq_2dyn() runs on A {
+ var template RoI tl_RoI1 := {1, 2, *};
+ var template RoI tl_RoI1p := {permutation(all from tl_RoI1)};
+ f_checkRoITemplateEquivalence(tl_RoI1p,t_SoI1p_eq);
+}
+
+testcase tc_permut1s_dyn() runs on A {
+ var template RoI tl_RoI1p := {permutation(all from t_SoI1)};
+ var RoRoI vl_goodValues := {{1,2},{2,1},{1,2,0},{1,2,1,2,3,4},{2,1,0},{2,1,222},{1,1,1,2,2,2,2} }
+ var RoRoI vl_badValues := {{},{1},{2},{3},{3,4,5},{3,4,5,1},{3,4,5,2}
+ }
+ f_checkRoITemplate(tl_RoI1p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut1s_2dyn() runs on A {
+ var template RoI tl_RoI1 := {1, 2, *};
+ var template RoI tl_RoI1p := {permutation(all from tl_RoI1)};
+ var RoRoI vl_goodValues := {{1,2},{2,1},{1,2,0},{1,2,1,2,3,4},{2,1,0},{2,1,222},{1,1,1,2,2,2,2} }
+ var RoRoI vl_badValues := {{},{1},{2},{3},{3,4,5},{3,4,5,1},{3,4,5,2}
+ }
+ f_checkRoITemplate(tl_RoI1p,vl_goodValues,vl_badValues);
+}
+//=== 2 ===
+testcase tc_permut2s_eq_dyn() runs on A {
+ var template RoI tl_RoI2p := {permutation(0, all from t_SoI1), 4, 5};
+ f_checkRoITemplateEquivalence(tl_RoI2p,t_SoI2p_eq);
+}
+
+testcase tc_permut2s_eq_2dyn() runs on A {
+ var template RoI tl_RoI1 := {1, 2, *};
+ var template RoI tl_RoI2p := {permutation(0, all from tl_RoI1), 4, 5};
+ f_checkRoITemplateEquivalence(tl_RoI2p,t_SoI2p_eq);
+}
+
+testcase tc_permut2s_dyn() runs on A {
+ var template RoI tl_RoI2p := {permutation(0, all from t_SoI1), 4, 5};
+ var RoRoI vl_goodValues := {
+ {0,1,2,4,5},{0,2,1,4,5},{1,0,2,4,5},{2,1,0,4,5},{1,2,0,4,5},
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ { -2, -1, 0, 1, 2, 3, 4, 5 },
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 4, 5 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4,5 }
+ };
+ var RoRoI vl_badValues := { {},{1},{1,2},{1,2,3},{1,2,3,4},{1,2,3,4,5},{0,1,2,3,4,6},{ 5, 4, 3, 2, 1, 0 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4 }};
+ f_checkRoITemplate(tl_RoI2p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut2s_2dyn() runs on A {
+ var template RoI tl_RoI1 := {1, 2, *};
+ log("debug1");
+ var template RoI tl_RoI2p := {permutation(0, all from tl_RoI1), 4, 5};
+ log("debug2");
+ var RoRoI vl_goodValues := {
+ {0,1,2,4,5},{0,2,1,4,5},{1,0,2,4,5},{2,1,0,4,5},{1,2,0,4,5},
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ { -2, -1, 0, 1, 2, 3, 4, 5 },
+ { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 4, 5 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4,5 }
+ };
+ var RoRoI vl_badValues := { {},{1},{1,2},{1,2,3},{1,2,3,4},{1,2,3,4,5},{0,1,2,3,4,6},{ 5, 4, 3, 2, 1, 0 },{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4 }};
+ f_checkRoITemplate(tl_RoI2p,vl_goodValues,vl_badValues);
+}
+
+//=== 3 ===
+testcase tc_permut3s_eq_dyn() runs on A {
+ var template RoI tl_RoI3p := {permutation(all from t_SoI3)}
+ f_checkRoITemplateEquivalence(tl_RoI3p,t_SoI3p_eq);
+}
+
+testcase tc_permut3s_eq_2dyn() runs on A {
+ var template RoI tl_RoI3 := {1, 2, 3};
+ var template RoI tl_RoI3p := {permutation(all from tl_RoI3)}
+ f_checkRoITemplateEquivalence(tl_RoI3p,t_SoI3p_eq);
+}
+
+testcase tc_permut3s_dyn() runs on A {
+ log("debug1");
+ var template RoI tl_RoI3p := {permutation(all from t_SoI3)}
+ log("debug2");
+ var RoRoI vl_goodValues := {
+ { 1,2,3},{1,3,2},
+ { 2,1,3},{2,3,1},
+ { 3,1,2},{3,2,1}
+ }
+ var RoRoI vl_badValues := { {},{1},{2},{3},{4},{1,2},{1,3},{1,4},{2,3},{1,2,3,4},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000}
+ }
+ f_checkRoITemplate(tl_RoI3p,vl_goodValues,vl_badValues);
+}
+testcase tc_permut3s_2dyn() runs on A {
+ var template RoI tl_RoI3 := {1, 2, 3};
+ log("debug1");
+ template RoI tl_RoI3p := {permutation(all from tl_RoI3)}
+ log("debug2");
+ var RoRoI vl_goodValues := {
+ { 1,2,3},{1,3,2},
+ { 2,1,3},{2,3,1},
+ { 3,1,2},{3,2,1}
+ }
+ var RoRoI vl_badValues := { {},{1},{2},{3},{4},{1,2},{1,3},{1,4},{2,3},{1,2,3,4},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000}
+ }
+ f_checkRoITemplate(tl_RoI3p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut3sA_dyn() runs on A {
+ var integer x:=1,y:=2,z:=3;
+ var template RoI tl_RoI3 := {x, y, z};
+ log("debug1");
+ //template RoI tl_RoI5p_dyn := {*,permutation(all from tl_RoI3p_dyn),*}
+ template RoI tl_RoI3p := {permutation(all from tl_RoI3)}
+ log("debug2");
+ var RoRoI vl_goodValues := {
+ { 1,2,3},{1,3,2 },
+ { 2,1,3},{2,3,1},
+ { 3,1,2},{3,2,1}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI3p,vl_goodValues,vl_badValues);
+}
+//=== 4 ===
+testcase tc_permut4s_eq_dyn() runs on A {
+ var template RoI tl_RoI4p := {?,permutation(0, all from t_SoI1), 4, 5};
+ f_checkRoITemplateEquivalence(tl_RoI4p,t_SoI4p_eq);
+}
+
+testcase tc_permut4s_eq_2dyn() runs on A {
+ var template RoI tl_RoI1 := {1, 2, *};
+ var template RoI tl_RoI4p := {?,permutation(0, all from tl_RoI1), 4, 5};
+ f_checkRoITemplateEquivalence(tl_RoI4p,t_SoI4p_eq);
+}
+
+
+testcase tc_permut4s_dyn() runs on A {
+ var template RoI tl_RoI4p := {permutation(0, all from t_SoI1), 4, 5}; //executor doesn't accept
+ var RoRoI vl_goodValues := {
+ {99,0,1,2,3,4,5}, {99,0,1,3,2,4,5},{99,0,2,1,3,4,5},{99,0,2,3,1,4,5},{99,0,3,2,1,4,5},{99,0,3,1,2,4,5},
+ {99,1,0,2,3,4,5}, {99,1,0,3,2,4,5},{99,1,2,0,3,4,5},{99,1,2,3,0,4,5},{99,1,3,2,0,4,5},{99,1,3,0,2,4,5},
+ {99,2,1,0,3,4,5}, {99,2,1,3,0,4,5},{99,2,0,1,3,4,5},{99,2,0,3,1,4,5},{99,2,3,0,1,4,5},{99,2,3,1,0,4,5},
+ {99,3,1,0,2,4,5}, {99,3,1,2,0,4,5},{99,3,0,1,2,4,5},{99,3,0,2,1,4,5},{99,3,2,0,1,4,5},{99,3,2,1,0,4,5},
+ {99,0,1,2,9,4,5}, {99,0,1,9,2,4,5},{99,0,2,1,9,4,5},{99,0,2,9,1,4,5},{99,0,9,2,1,4,5},{99,0,9,1,2,4,5},
+ {99,1,0,2,9,4,5}, {99,1,0,9,2,4,5},{99,1,2,0,9,4,5},{99,1,2,9,0,4,5},{99,1,9,2,0,4,5},{99,1,9,0,2,4,5},
+ {99,2,1,0,9,4,5}, {99,2,1,9,0,4,5},{99,2,0,1,9,4,5},{99,2,0,9,1,4,5},{99,2,9,0,1,4,5},{99,2,9,1,0,4,5},
+ {99,9,1,0,2,4,5}, {99,9,1,2,0,4,5},{99,9,0,1,2,4,5},{99,9,0,2,1,4,5},{99,9,2,0,1,4,5},{99,9,2,1,0,4,5},
+ {99,9,1,9,0,2,4,5}, {99,9,1,2,9,0,4,5},{99,9,0,9,1,9,2,9,4,5},{99,9,0,2,1,4,5},{99,9,2,0,1,4,5},{99,9,2,1,0,4,5}
+ };
+ var RoRoI vl_badValues := { {},{1},{1,2},{1,2,3},{1,2,3,4},{1,2,3,4,5},{0,1,2,3,5,4},{0,1,2,3,4,6},{ 5, 4, 3, 2, 1, 0 },{1,1,1,1,1,1}};
+ f_checkRoITemplate(tl_RoI4p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut4s_2dyn() runs on A {
+ var template RoI tl_RoI1 := {1, 2, *};
+ var template RoI tl_RoI4p := {permutation(0, all from tl_RoI1), 4, 5}; //executor doesn't accept
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ {0,1,2,9,4,5}, {0,1,9,2,4,5},{0,2,1,9,4,5},{0,2,9,1,4,5},{0,9,2,1,4,5},{0,9,1,2,4,5},
+ {1,0,2,9,4,5}, {1,0,9,2,4,5},{1,2,0,9,4,5},{1,2,9,0,4,5},{1,9,2,0,4,5},{1,9,0,2,4,5},
+ {2,1,0,9,4,5}, {2,1,9,0,4,5},{2,0,1,9,4,5},{2,0,9,1,4,5},{2,9,0,1,4,5},{2,9,1,0,4,5},
+ {9,1,0,2,4,5}, {9,1,2,0,4,5},{9,0,1,2,4,5},{9,0,2,1,4,5},{9,2,0,1,4,5},{9,2,1,0,4,5},
+ {9,1,9,0,2,4,5}, {9,1,2,9,0,4,5},{9,0,9,1,9,2,9,4,5},{9,0,2,1,4,5},{9,2,0,1,4,5},{9,2,1,0,4,5}
+ };
+ var RoRoI vl_badValues := { {},{1},{1,2},{1,2,3},{1,2,3,4},{1,2,3,4,5},{0,1,2,3,5,4},{0,1,2,3,4,6},{ 5, 4, 3, 2, 1, 0 },{1,1,1,1,1,1}};
+ f_checkRoITemplate(tl_RoI4p,vl_goodValues,vl_badValues);
+}
+
+//=== 5 ===
+
+//{*,permutation(1,2,3),*}
+testcase tc_permut5s_eq_dyn() runs on A {
+ var template RoI tl_RoI5p := {*,permutation(all from t_SoI3),*}
+ f_checkRoITemplateEquivalence(tl_RoI5p,t_SoI5p_eq);
+}
+
+testcase tc_permut5s_eq_2dyn() runs on A {
+ var template RoI tl_RoI3 := {1, 2, 3};
+ var template RoI tl_RoI5p := {*,permutation(all from tl_RoI3),*}
+ f_checkRoITemplateEquivalence(tl_RoI5p,t_SoI5p_eq);
+}
+
+testcase tc_permut5s_dyn() runs on A {
+ var template RoI tl_RoI5p := {*,permutation(all from t_SoI3),*}
+ var RoRoI vl_goodValues := {
+ {1,2,3},{1,3,2},
+ {2,1,3},{2,3,1},
+ {3,1,2},{3,2,1},
+ {0,2,1,3},{0,2,1,3,0},
+ {-200,200,0,1,2,3,-1000},{-200,200,0,1,3,2,-1000},
+ {-200,200,0,2,1,3,-1000},{-200,200,0,2,3,1,-1000},
+ {-200,200,0,3,1,2,-1000},{-200,200,0,3,2,1,-1000},
+ {1,-200,200,0,1,2,3,-1000},{1,-200,200,0,1,3,2,-1000},
+ {2,-200,200,0,2,1,3,-1000,2},{1,2,-200,200,0,2,3,1,-1000,2,1},
+ {-200,200,0,3,1,2,-1000},{-200,200,0,3,2,1,-1000}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI5p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut5s_2dyn() runs on A {
+ var template RoI tl_RoI3 := {1, 2, 3};
+ var template RoI tl_RoI5p := {*,permutation(all from tl_RoI3),*}
+ var RoRoI vl_goodValues := {
+ { 1,2,3},{1,3,2},
+ { 2,1,3},{2,3,1},
+ { 3,1,2},{ 3,2,1},
+ {0,2,1,3},{0,2,1,3,0},
+ {-200,200,0,1,2,3,-1000},{-200,200,0,1,3,2,-1000},
+ {-200,200,0,2,1,3,-1000},{-200,200,0,2,3,1,-1000},
+ {-200,200,0,3,1,2,-1000},{-200,200,0,3,2,1,-1000},
+ {1,-200,200,0,1,2,3,-1000},{1,-200,200,0,1,3,2,-1000},
+ {2,-200,200,0,2,1,3,-1000,2},{1,2,-200,200,0,2,3,1,-1000,2,1},
+ {-200,200,0,3,1,2,-1000},{-200,200,0,3,2,1,-1000}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI5p,vl_goodValues,vl_badValues);
+}
+//=== 6 ===
+//{?,permutation(1,2,3),4}
+testcase tc_permut6s_eq_dyn() runs on A {
+ var template RoI tl_RoI6p := {?,permutation(all from t_SoI3),4};
+ f_checkRoITemplateEquivalence(tl_RoI6p,t_SoI6p_eq);
+}
+
+testcase tc_permut6s_eq_2dyn() runs on A {
+ var template RoI tl_RoI3 := {1, 2, 3};
+ var template RoI tl_RoI6p := {?,permutation(all from tl_RoI3),4};
+ f_checkRoITemplateEquivalence(tl_RoI6p,t_SoI6p_eq);
+}
+
+testcase tc_permut6s_dyn() runs on A {
+ var template RoI tl_RoI6p := {?,permutation(all from t_SoI3),4} //(?,permutation(1,2,3),4)
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4},{0,1,3,2,4},
+ {0,2,1,3,4},{0,2,3,1,4},
+ {0,3,1,2,4},{0,3,2,1,4},
+ {1,1,2,3,4},{1,1,3,2,4},
+ {1,2,1,3,4},{1,2,3,1,4},
+ {1,3,1,2,4},{1,3,2,1,4},
+ {2,1,2,3,4},{2,1,3,2,4},
+ {2,2,1,3,4},{2,2,3,1,4},
+ {2,3,1,2,4},{2,3,2,1,4},
+ {3,1,2,3,4},{3,1,3,2,4},
+ {3,2,1,3,4},{3,2,3,1,4},
+ {3,3,1,2,4},{3,3,2,1,4},
+
+ {9,1,2,3,4},{9,1,3,2,4},
+ {9,2,1,3,4},{9,2,3,1,4},
+ {9,3,1,2,4},{9,3,2,1,4},
+
+ {5,1,2,3,4},{5,1,3,2,4},
+ {5,2,1,3,4},{5,2,3,1,4},
+ {5,3,1,2,4},{5,3,2,1,4},
+
+ {99,1,2,3,4},{-5,1,3,2,4},
+ {1,2,1,3,4},{2,2,3,1,4},
+ {3,3,1,2,4},{4,3,2,1,4}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ {1,2,3},{1,3,2},
+ {0,2,1,3},{0,2,3,1},
+ {3,1,2},{3,2,1},
+
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI6p,vl_goodValues,vl_badValues);
+}
+testcase tc_permut6s_2dyn() runs on A {
+ var template RoI tl_RoI3 := {1, 2, 3};
+ var template RoI tl_RoI6p := {?,permutation(all from tl_RoI3),4};
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4},{0,1,3,2,4},
+ {0,2,1,3,4},{0,2,3,1,4},
+ {0,3,1,2,4},{0,3,2,1,4},
+
+ {1,1,2,3,4},{1,1,3,2,4},
+ {1,2,1,3,4},{1,2,3,1,4},
+ {1,3,1,2,4},{1,3,2,1,4},
+ {2,1,2,3,4},{2,1,3,2,4},
+ {2,2,1,3,4},{2,2,3,1,4},
+ {2,3,1,2,4},{2,3,2,1,4},
+ {3,1,2,3,4},{3,1,3,2,4},
+ {3,2,1,3,4},{3,2,3,1,4},
+ {3,3,1,2,4},{3,3,2,1,4},
+
+ {9,1,2,3,4},{9,1,3,2,4},
+ {9,2,1,3,4},{9,2,3,1,4},
+ {9,3,1,2,4},{9,3,2,1,4},
+
+ {5,1,2,3,4},{5,1,3,2,4},
+ {5,2,1,3,4},{5,2,3,1,4},
+ {5,3,1,2,4},{5,3,2,1,4},
+
+ {99,1,2,3,4},{-5,1,3,2,4},
+ {1,2,1,3,4},{2,2,3,1,4},
+ {3,3,1,2,4},{4,3,2,1,4}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ { 1,2,3},{1,3,2},
+ { 0,2,1,3},{0,2,3,1},
+ { 3,1,2},{ 3,2,1},
+
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI6p,vl_goodValues,vl_badValues);
+}
+testcase tc_permut6sA_dyn() runs on A {
+ var integer x:=1,y:=2,z:=3;
+ var template RoI tl_RoI3 := {x, y, z};
+ var template RoI tl_RoI6p := {?,permutation(all from tl_RoI3),4}
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4},{0,1,3,2,4},
+ {0,2,1,3,4},{0,2,3,1,4},
+ {0,3,1,2,4},{0,3,2,1,4},
+ {1,1,2,3,4},{1,1,3,2,4},
+ {1,2,1,3,4},{1,2,3,1,4},
+ {1,3,1,2,4},{1,3,2,1,4},
+ {2,1,2,3,4},{2,1,3,2,4},
+ {2,2,1,3,4},{2,2,3,1,4},
+ {2,3,1,2,4},{2,3,2,1,4},
+ {3,1,2,3,4},{3,1,3,2,4},
+ {3,2,1,3,4},{3,2,3,1,4},
+ {3,3,1,2,4},{3,3,2,1,4},
+ {9,1,2,3,4},{9,1,3,2,4},
+ {9,2,1,3,4},{9,2,3,1,4},
+ {9,3,1,2,4},{9,3,2,1,4},
+
+ {5,1,2,3,4},{5,1,3,2,4},
+ {5,2,1,3,4},{5,2,3,1,4},
+ {5,3,1,2,4},{5,3,2,1,4},
+
+ {99,1,2,3,4},{-5,1,3,2,4},
+ {1,2,1,3,4},{2,2,3,1,4},
+ {3,3,1,2,4},{4,3,2,1,4}}
+ var RoRoI vl_badValues := { {},{1},{1,2},
+ { 1,2,3},{1,3,2},
+ { 2,1,3},{2,3,1},
+ { 3,1,2},{ 3,2,1},
+ { 0,1,2,3},{1,1,3,2},
+ { 2,2,1,3},{3,2,3,1},
+ { 4,3,1,2},{5,3,2,1},
+ { 1,2,3,4},{1,3,2,4},
+ { 2,1,3,4},{2,3,1,4},
+ { 3,1,2,4},{ 3,2,1,4},
+ { 0,1,2,3,5},{1,1,3,2,6},
+ { 2,2,1,3,7},{3,2,3,1,8},
+ { 4,3,1,2,9},{5,3,2,1,10},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI6p,vl_goodValues,vl_badValues);
+}
+
+//=== 7 ===
+//{permutation{1, 2, ?}};
+testcase tc_permut7s_eq_dyn() runs on A {
+ var template RoI tl_RoI7p := {permutation(all from t_SoI7)};
+ f_checkRoITemplateEquivalence(tl_RoI7p,t_SoI7p_eq);
+}
+
+testcase tc_permut7s_eq_2dyn() runs on A {
+ var template RoI tl_RoI7 := {1, 2, ?};
+ var template RoI tl_RoI7p := {permutation(all from tl_RoI7)};
+ f_checkRoITemplateEquivalence(tl_RoI7p,t_SoI7p_eq);
+}
+
+testcase tc_permut7s_dyn() runs on A {
+ var template RoI tl_RoI7p := {permutation(all from t_SoI7)};
+ var RoRoI vl_goodValues := {
+ {1,2,3},{1,2,4},{1,2,5},{1,2,1000},
+ {1,3,2},{1,4,2},{1,5,2},{1,6,2},
+ {2,1,3},{2,1,4},{2,1,5},{2,1,6},
+ {3,1,2},{3,2,1},{4,1,2},{4,2,1},
+ {1000,1,2},{1,1000,2}
+ }
+ var RoRoI vl_badValues := { {},{1},{2},{3},{9999},{1,2},{2,1}, {13,31},
+ { 0,2,1,3},{0,2,3,1},{0,2,3,1,5},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI7p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut7s_2dyn() runs on A {
+ var template RoI tl_RoI7 := {1, 2, ?};
+ var template RoI tl_RoI7p := {permutation(all from tl_RoI7)};
+ var RoRoI vl_goodValues := {
+ {1,2,3}, {1,2,4},{1,2,5},{1,2,1000},
+ {1,3,2},{1,4,2},{1,5,2},{1,6,2},
+ {2,1,3},{2,1,4},{2,1,5},{2,1,6},
+ {3,1,2},{3,2,1},{4,1,2},{4,2,1},
+ {1000,1,2},{1,1000,2}
+ }
+ var RoRoI vl_badValues := { {},{1},{2},{3},{9999},{1,2},{2,1}, {13,31},
+ { 0,2,1,3},{0,2,3,1},
+ {-200,200,0,2,3,-1000},{-200,200,0,3,2,-1000},
+ {-200,200,0,1,3,-1000},{-200,200,0,3,1,-1000},
+ {-200,200,0,1,2,-1000},{-200,200,0,2,1,-1000},
+ {-200,200,0,2,-1000},{-200,200,0,3,-1000},{-200,200,0,1,-1000},
+ {1,2,100,3},{1,100,2,3},{1,100,2,200,3}
+ }
+ f_checkRoITemplate(tl_RoI7p,vl_goodValues,vl_badValues);
+}
+
+//=== 8 ===
+//{permutation(0,1,2,?),4,5}
+
+testcase tc_permut8s_eq_dyn() runs on A {
+ var template RoI tl_RoI8p := {permutation(0, all from t_SoI7), 4, 5};
+ f_checkRoITemplateEquivalence(tl_RoI8p,t_SoI8p_eq);
+}
+
+testcase tc_permut8s_eq_2dyn() runs on A {
+ var template RoI tl_RoI7 := {1, 2, ?};
+ var template RoI tl_RoI8p := {permutation(0, all from tl_RoI7), 4, 5};
+ f_checkRoITemplateEquivalence(tl_RoI8p,t_SoI8p_eq);
+}
+
+testcase tc_permut8s_dyn() runs on A {
+ var template RoI tl_RoI8p := {permutation(0, all from t_SoI7), 4, 5};
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ {0,1,2,9,4,5}, {0,1,9,2,4,5},{0,2,1,9,4,5},{0,2,9,1,4,5},{0,9,2,1,4,5},{0,9,1,2,4,5},
+ {1,0,2,9,4,5}, {1,0,9,2,4,5},{1,2,0,9,4,5},{1,2,9,0,4,5},{1,9,2,0,4,5},{1,9,0,2,4,5},
+ {2,1,0,9,4,5}, {2,1,9,0,4,5},{2,0,1,9,4,5},{2,0,9,1,4,5},{2,9,0,1,4,5},{2,9,1,0,4,5},
+ {9,1,0,2,4,5}, {9,1,2,0,4,5},{9,0,1,2,4,5},{9,0,2,1,4,5},{9,2,0,1,4,5},{9,2,1,0,4,5}
+ }
+ var RoRoI vl_badValues := { {},{1},{1,2},{9,1,9,0,2,4,5}, {9,1,2,9,0,4,5},{9,0,9,1,9,2,9,4,5}
+
+ }
+ f_checkRoITemplate(tl_RoI8p,vl_goodValues,vl_badValues);
+}
+
+testcase tc_permut8s_2dyn() runs on A {
+ var template RoI tl_RoI7 := {1, 2, ?};
+ var template RoI tl_RoI8p := {permutation(0, all from tl_RoI7), 4, 5};
+ var RoRoI vl_goodValues := {
+ {0,1,2,3,4,5}, {0,1,3,2,4,5},{0,2,1,3,4,5},{0,2,3,1,4,5},{0,3,2,1,4,5},{0,3,1,2,4,5},
+ {1,0,2,3,4,5}, {1,0,3,2,4,5},{1,2,0,3,4,5},{1,2,3,0,4,5},{1,3,2,0,4,5},{1,3,0,2,4,5},
+ {2,1,0,3,4,5}, {2,1,3,0,4,5},{2,0,1,3,4,5},{2,0,3,1,4,5},{2,3,0,1,4,5},{2,3,1,0,4,5},
+ {3,1,0,2,4,5}, {3,1,2,0,4,5},{3,0,1,2,4,5},{3,0,2,1,4,5},{3,2,0,1,4,5},{3,2,1,0,4,5},
+ {0,1,2,9,4,5}, {0,1,9,2,4,5},{0,2,1,9,4,5},{0,2,9,1,4,5},{0,9,2,1,4,5},{0,9,1,2,4,5},
+ {1,0,2,9,4,5}, {1,0,9,2,4,5},{1,2,0,9,4,5},{1,2,9,0,4,5},{1,9,2,0,4,5},{1,9,0,2,4,5},
+ {2,1,0,9,4,5}, {2,1,9,0,4,5},{2,0,1,9,4,5},{2,0,9,1,4,5},{2,9,0,1,4,5},{2,9,1,0,4,5},
+ {9,1,0,2,4,5}, {9,1,2,0,4,5},{9,0,1,2,4,5},{9,0,2,1,4,5},{9,2,0,1,4,5},{9,2,1,0,4,5}
+ }
+ var RoRoI vl_badValues := { {},{1},{1,2},{9,1,9,0,2,4,5}, {9,1,2,9,0,4,5},{9,0,9,1,9,2,9,4,5}
+
+ }
+ f_checkRoITemplate(tl_RoI8p,vl_goodValues,vl_badValues);
+}
+
+//************************* Testcases for Templates of type Record of charstring ******************************
+
+//=== 1 ===
+testcase tc_CharstringTemplate1_eq() runs on A
+{
+ f_checkRoCSTemplateEquivalence(t_rocs1,t_rocs1_eq);
+}
+testcase tc_CharstringTemplate1_eq_local() runs on A
+{
+ template RoCS tl_rocs1 := { permutation ( all from t_RoCS1 ) };
+ f_checkRoCSTemplateEquivalence(tl_rocs1,t_rocs1_eq);
+}
+testcase tc_CharstringTemplate1_eq_dyn() runs on A
+{
+ var template RoCS tl_rocs1 := { permutation ( all from t_RoCS1 ) };
+ f_checkRoCSTemplateEquivalence(tl_rocs1,t_rocs1_eq);
+}
+
+testcase tc_CharstringTemplate1_eq_local_dyn() runs on A
+{
+ template RoCS tl_RoCS1 := { "apple","banana","","pear"};
+ var template RoCS tl_rocs1 := { permutation ( all from tl_RoCS1 ) };
+ f_checkRoCSTemplateEquivalence(tl_rocs1,t_rocs1_eq);
+}
+
+testcase tc_CharstringTemplate1_eq_2dyn() runs on A
+{
+ var template RoCS tl_RoCS1 := { "apple","banana","","pear"};
+ var template RoCS tl_rocs1 := { permutation ( all from tl_RoCS1 ) };
+ f_checkRoCSTemplateEquivalence(tl_rocs1,t_rocs1_eq);
+}
+
+//=== 2 ===
+testcase tc_CharstringTemplate2_eq() runs on A
+{
+ f_checkRoCSTemplateEquivalence(t_rocs2,t_rocs2_eq);
+}
+testcase tc_CharstringTemplate2_eq_local() runs on A
+{
+ template RoCS tl_rocs2 := { permutation( "treeeeeeeeeeeeee",all from t_RoCS1, "dog", all from t_RoCS2) };
+ f_checkRoCSTemplateEquivalence(tl_rocs2,t_rocs2_eq);
+}
+testcase tc_CharstringTemplate2_eq_dyn() runs on A
+{
+ var template RoCS tl_rocs2 := { permutation( "treeeeeeeeeeeeee",all from t_RoCS1, "dog", all from t_RoCS2) };
+ f_checkRoCSTemplateEquivalence(tl_rocs2,t_rocs2_eq);
+}
+
+testcase tc_CharstringTemplate2_eq_local_dyn() runs on A
+{
+ template RoCS tl_RoCS1 := { "apple","banana","","pear"};
+ template RoCS tl_RoCS2 := { "apples","bananas","","pears"};
+ var template RoCS tl_rocs2 := { permutation( "treeeeeeeeeeeeee",all from tl_RoCS1, "dog", all from tl_RoCS2) };
+ f_checkRoCSTemplateEquivalence(tl_rocs2,t_rocs2_eq);
+}
+
+
+testcase tc_CharstringTemplate2_eq_2dyn() runs on A
+{
+ var template RoCS tl_RoCS1 := { "apple","banana","","pear"};
+ var template RoCS tl_RoCS2 := { "apples","bananas","","pears"};
+ var template RoCS tl_rocs2 := { permutation( "treeeeeeeeeeeeee",all from tl_RoCS1, "dog", all from tl_RoCS2) };
+ f_checkRoCSTemplateEquivalence(tl_rocs2,t_rocs2_eq);
+}
+
+//==== function reference =====
+testcase tc_functionRef_rof_p_eq() runs on A {
+ f_checkMyRoFRefTemplateEquivalence( t_fref_int2int_p,t_fref_int2int_p_eq);
+}
+
+// permutation all from with length restriction
+// 1. the target of 'all from' is foldable (known at compile-time)
+testcase tc_perm_varTemplate_len_res_foldable() runs on A
+{
+ template RoI tl_foldable := { 6, 9 };
+ var template RoI tl_len_res := { permutation ( 2, all from tl_foldable ) } length (3);
+ var template RoI tl_len_res_eq := { permutation ( 2, 6, 9 ) } length (3);
+ f_checkRoITemplateEquivalence(tl_len_res, tl_len_res_eq);
+}
+
+// 2. the target of 'all from' is unfoldable (not known at compile-time)
+testcase tc_perm_varTemplate_len_res_unfoldable() runs on A
+{
+ var template RoI tl_unfoldable := { 6, 9 };
+ var template RoI tl_len_res := { permutation ( 2, all from tl_unfoldable ) } length (3);
+ var template RoI tl_len_res_eq := { permutation ( 2, 6, 9 ) } length (3);
+ f_checkRoITemplateEquivalence(tl_len_res, tl_len_res_eq);
+}
+
+testcase tc_perm_varTemplate_two_var_unfoldable() runs on A
+{
+ var template RoI tl_unfoldable := { 6, 9 };
+ var template RoI tl_unfoldable2 := { 5, 7 };
+ var template RoI tl_unfoldable3 := { 10, 11 };
+ var template RoI tl_len_res := { permutation ( 2, all from tl_unfoldable, all from tl_unfoldable2), permutation (all from tl_unfoldable3) };
+ var template RoI tl_len_res_eq := { permutation ( 2, 6, 9, 5, 7 ), permutation (10, 11) };
+ f_checkRoITemplateEquivalence(tl_len_res, tl_len_res_eq);
+}
+
+testcase tc_perm_varTemplate_array_unfoldable() runs on A
+{
+ var template RoI tl_unfoldable4 := { 6 };
+ var template IntArray tl_arr_res := { 1, permutation ( 2, all from tl_unfoldable4, 3), 4, 5 };
+ var template IntArray tl_arr_res_eq := { 1, permutation ( 2, 6, 3 ), 4, 5 };
+ if (log2str(tl_arr_res) != log2str(tl_arr_res_eq)) {
+ setverdict(fail, match(log2str(tl_arr_res), log2str(tl_arr_res_eq)));
+ }
+ setverdict(pass);
+}
+
+control{
+ execute(tc_permut());
+execute(tc_permut1_eq());
+execute(tc_permutImporting1_eq());
+execute(tc_permut1());
+execute(tc_permutImporting1());
+execute(tc_permut2_eq());
+execute(tc_permutImporting2_eq());
+execute(tc_permut2());
+execute(tc_permutImporting2());
+execute(tc_permut3_eq());
+execute(tc_permutImporting3_eq());
+execute(tc_permut3());
+execute(tc_permut4_eq());
+execute(tc_permut4());
+execute(tc_permut5_eq());
+execute(tc_permut5());
+execute(tc_permut6_eq());
+execute(tc_permut6());
+execute(tc_permut7_eq());
+execute(tc_permut7());
+execute(tc_permut8_eq());
+execute(tc_permut8());
+execute(tc_permut13roi_eq());
+execute(tc_permut13roi());
+execute(tc_permut13soi_eq());
+execute(tc_permut13soi());
+execute(tc_permut13roi_c_eq());
+execute(tc_permut13roi_c());
+execute(tc_permut13soi_c_eq());
+execute(tc_permut13soi_c());
+execute(tc_permut1_eq_dyn());
+execute(tc_permut1_eq_2dyn());
+execute(tc_permut1_dyn());
+execute(tc_permut1_2dyn());
+execute(tc_permut2_eq_dyn());
+execute(tc_permut2_eq_2dyn());
+execute(tc_permut2_dyn());
+execute(tc_permut2_2dyn());
+execute(tc_permut3_eq_dyn());
+execute(tc_permut3_eq_2dyn());
+execute(tc_permut3_dyn());
+execute(tc_permut3_2dyn());
+execute(tc_permut3A_dyn());
+execute(tc_permut4_eq_dyn());
+execute(tc_permut4_eq_2dyn());
+execute(tc_permut4_dyn());
+execute(tc_permut4_2dyn());
+execute(tc_permut5_eq_dyn());
+execute(tc_permut5_eq_2dyn());
+execute(tc_permut5_dyn());
+execute(tc_permut5_2dyn());
+execute(tc_permut6_eq_dyn());
+execute(tc_permut6_eq_2dyn());
+execute(tc_permut6_dyn());
+execute(tc_permut6_2dyn());
+execute(tc_permut6A_dyn());
+execute(tc_permut7_eq_dyn());
+execute(tc_permut7_eq_2dyn());
+execute(tc_permut7_dyn());
+execute(tc_permut7_2dyn());
+execute(tc_permut8_eq_dyn());
+execute(tc_permut8_eq_2dyn());
+execute(tc_permut8_dyn());
+execute(tc_permut8_2dyn());
+execute(tc_permut1s_eq());
+execute(tc_permut1s());
+execute(tc_permut2s_eq());
+execute(tc_permut2s());
+execute(tc_permut3s_eq());
+execute(tc_permut3s());
+execute(tc_permut4s_eq());
+execute(tc_permut4s());
+execute(tc_permut5s_eq());
+execute(tc_permut5s());
+execute(tc_permut6s_eq());
+execute(tc_permut6s());
+execute(tc_permut7s_eq());
+execute(tc_permut7s());
+execute(tc_permut8s_eq());
+execute(tc_permut8s());
+execute(tc_permut1s_eq_dyn());
+execute(tc_permut1s_eq_2dyn());
+execute(tc_permut1s_dyn());
+execute(tc_permut1s_2dyn());
+execute(tc_permut2s_eq_dyn());
+execute(tc_permut2s_eq_2dyn());
+execute(tc_permut2s_dyn());
+execute(tc_permut2s_2dyn());
+execute(tc_permut3s_eq_dyn());
+execute(tc_permut3s_eq_2dyn());
+execute(tc_permut3s_dyn());
+execute(tc_permut3s_2dyn());
+execute(tc_permut3sA_dyn());
+execute(tc_permut4s_eq_dyn());
+execute(tc_permut4s_eq_2dyn());
+execute(tc_permut4s_dyn());
+execute(tc_permut4s_2dyn());
+execute(tc_permut5s_eq_dyn());
+execute(tc_permut5s_eq_2dyn());
+execute(tc_permut5s_dyn());
+execute(tc_permut5s_2dyn());
+execute(tc_permut6s_eq_dyn());
+execute(tc_permut6s_eq_2dyn());
+execute(tc_permut6s_dyn());
+execute(tc_permut6s_2dyn());
+execute(tc_permut6sA_dyn());
+execute(tc_permut7s_eq_dyn());
+execute(tc_permut7s_eq_2dyn());
+execute(tc_permut7s_dyn());
+execute(tc_permut7s_2dyn());
+execute(tc_permut8s_eq_dyn());
+execute(tc_permut8s_eq_2dyn());
+execute(tc_permut8s_dyn());
+execute(tc_permut8s_2dyn());
+execute(tc_CharstringTemplate1_eq());
+execute(tc_CharstringTemplate1_eq_local());
+execute(tc_CharstringTemplate1_eq_dyn());
+execute(tc_CharstringTemplate1_eq_local_dyn());
+execute(tc_CharstringTemplate1_eq_2dyn());
+execute(tc_CharstringTemplate2_eq());
+execute(tc_CharstringTemplate2_eq_local());
+execute(tc_CharstringTemplate2_eq_dyn());
+execute(tc_CharstringTemplate2_eq_local_dyn());
+execute(tc_CharstringTemplate2_eq_2dyn());
+execute(tc_functionRef_rof_p_eq());
+execute(tc_perm_varTemplate_len_res_foldable());
+execute(tc_perm_varTemplate_len_res_unfoldable());
+execute(tc_perm_varTemplate_two_var_unfoldable());
+execute(tc_perm_varTemplate_array_unfoldable());
+}
+} // end of module
diff --git a/Regression_Test_java/src/all_from/all_from_subrefs.ttcn b/Regression_Test_java/src/all_from/all_from_subrefs.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..28f4fe300d8f041d5e049afaf8dcb1a4bf1a8aae
--- /dev/null
+++ b/Regression_Test_java/src/all_from/all_from_subrefs.ttcn
@@ -0,0 +1,289 @@
+/******************************************************************************
+ * 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
+ *
+ ******************************************************************************/
+
+module all_from_subrefs {
+
+// in these tests the targets of 'all from' contain subreferences (array indexes and/or fields names)
+
+import from types all;
+
+// source templates and constants
+template MyRecord t_rec := { i := omit, roi := { 1, 3, 5 }, soi := { 2, 4, 6 } };
+template RoRoI t_roroi := { { 1, 2, 3 }, { 4, 5 }, { 6, 7, 8 } };
+template RoSoI t_rosoi(in integer x) := { { 10, 20, 30 }, { x, x * 2 } };
+const RoMyRec c_rorec := { { i := omit, roi := { -1, -3, -5 }, soi := { -2, -4, -6 } }, { i := 0, roi := omit, soi := { -10, -20, -30 } } };
+const RoMyUnion c_rouni := { { roi := { 11, 22, 33 } }, { soi := { -11, -22, -33 } } };
+const MyUnion c_uni := { roi := { 7, 77, 777 } };
+
+// just 'all from'
+template integer t_sr1 := ( 0, all from t_rec.soi, 8, 10 );
+template integer t_sr1_exp := ( 0, 2, 4, 6, 8, 10 );
+
+template integer t_sr2 := ( all from t_rec.roi, all from t_roroi[2] );
+template integer t_sr2_exp := ( 1, 3, 5, 6, 7, 8 );
+
+template integer t_sr3 := ( all from t_rosoi(100)[0], all from c_rorec[1].soi );
+template integer t_sr3_exp := ( 10, 20, 30, -10, -20, -30 );
+
+template integer t_sr4 := ( 0, all from c_rouni[0].roi, 44 );
+template integer t_sr4_exp := ( 0, 11, 22, 33, 44 );
+
+template integer t_sr5 := ( all from c_uni.roi );
+template integer t_sr5_exp := ( 7, 77, 777 );
+
+testcase tc_all_from_subrefs() runs on A
+{
+ if (log2str(t_sr1) != log2str(t_sr1_exp)) {
+ setverdict(fail, "Expected: ", t_sr1_exp, ", got: ", t_sr1);
+ }
+ if (log2str(t_sr2) != log2str(t_sr2_exp)) {
+ setverdict(fail, "Expected: ", t_sr2_exp, ", got: ", t_sr2);
+ }
+ if (log2str(t_sr3) != log2str(t_sr3_exp)) {
+ setverdict(fail, "Expected: ", t_sr3_exp, ", got: ", t_sr3);
+ }
+ if (log2str(t_sr4) != log2str(t_sr4_exp)) {
+ setverdict(fail, "Expected: ", t_sr4_exp, ", got: ", t_sr4);
+ }
+ if (log2str(t_sr5) != log2str(t_sr5_exp)) {
+ setverdict(fail, "Expected: ", t_sr5_exp, ", got: ", t_sr5);
+ }
+ setverdict(pass);
+}
+
+// permutation + all from
+template RoI t_sr_perm1 := { permutation ( all from t_rec.roi ) };
+template RoI t_sr_perm1_exp := { permutation ( 1, 3, 5 ) };
+
+template RoI t_sr_perm2 := { permutation ( 3, all from t_roroi[1], all from t_roroi[2] ) };
+template RoI t_sr_perm2_exp := { permutation ( 3, 4, 5, 6, 7, 8 ) };
+
+template RoI t_sr_perm3 := { permutation ( all from c_rorec[0].roi, all from c_rorec[0].soi ) };
+template RoI t_sr_perm3_exp := { permutation ( -1, -3, -5, -2, -4, -6 ) };
+
+testcase tc_all_from_subrefs_permutation() runs on A
+{
+ if (log2str(t_sr_perm1) != log2str(t_sr_perm1_exp)) {
+ setverdict(fail, "Expected: ", t_sr_perm1_exp, ", got: ", t_sr_perm1);
+ }
+ if (log2str(t_sr_perm2) != log2str(t_sr_perm2_exp)) {
+ setverdict(fail, "Expected: ", t_sr_perm2_exp, ", got: ", t_sr_perm2);
+ }
+ if (log2str(t_sr_perm3) != log2str(t_sr_perm3_exp)) {
+ setverdict(fail, "Expected: ", t_sr_perm3_exp, ", got: ", t_sr_perm3);
+ }
+ setverdict(pass);
+}
+
+// subset + all from
+template SoI t_sr_sub1 := subset ( all from c_rouni[1].soi );
+template SoI t_sr_sub1_exp := subset ( -11, -22, -33 );
+
+template SoI t_sr_sub2 := subset ( all from t_rec.soi, 2, all from t_roroi[0] );
+template SoI t_sr_sub2_exp := subset ( 2, 4, 6, 2, 1, 2, 3 );
+
+template SoI t_sr_sub3 := subset ( all from t_rosoi(100)[1], all from c_rorec[0].roi, all from c_rorec[0].roi );
+template SoI t_sr_sub3_exp := subset ( 100, 200, -1, -3, -5, -1, -3, -5 );
+
+testcase tc_all_from_subrefs_subset() runs on A
+{
+ if (log2str(t_sr_sub1) != log2str(t_sr_sub1_exp)) {
+ setverdict(fail, "Expected: ", t_sr_sub1_exp, ", got: ", t_sr_sub1);
+ }
+ if (log2str(t_sr_sub2) != log2str(t_sr_sub2_exp)) {
+ setverdict(fail, "Expected: ", t_sr_sub2_exp, ", got: ", t_sr_sub2);
+ }
+ if (log2str(t_sr_sub3) != log2str(t_sr_sub3_exp)) {
+ setverdict(fail, "Expected: ", t_sr_sub3_exp, ", got: ", t_sr_sub3);
+ }
+ setverdict(pass);
+}
+
+// superset + all from
+template SoI t_sr_super1 := superset ( all from c_rouni[0].roi );
+template SoI t_sr_super1_exp := superset ( 11, 22, 33 );
+
+template SoI t_sr_super2 := superset ( all from t_rec.roi, 2, all from t_roroi[1] );
+template SoI t_sr_super2_exp := superset ( 1, 3, 5, 2, 4, 5 );
+
+template SoI t_sr_super3 := superset ( all from t_rosoi(100)[0], all from c_rorec[1].soi, all from c_rorec[1].soi );
+template SoI t_sr_super3_exp := superset ( 10, 20, 30, -10, -20, -30, -10, -20, -30 );
+
+testcase tc_all_from_subrefs_superset() runs on A
+{
+ if (log2str(t_sr_super1) != log2str(t_sr_super1_exp)) {
+ setverdict(fail, "Expected: ", t_sr_super1_exp, ", got: ", t_sr_super1);
+ }
+ if (log2str(t_sr_super2) != log2str(t_sr_super2_exp)) {
+ setverdict(fail, "Expected: ", t_sr_super2_exp, ", got: ", t_sr_super2);
+ }
+ if (log2str(t_sr_super3) != log2str(t_sr_super3_exp)) {
+ setverdict(fail, "Expected: ", t_sr_super3_exp, ", got: ", t_sr_super3);
+ }
+ setverdict(pass);
+}
+
+// all from + variables / template variables
+testcase tc_all_from_subrefs_var() runs on A
+{
+ // source variables
+ var MyRecord v_rec := { i := omit, roi := { 2, 1, 0 }, soi := { 7, 1, 5 } };
+ var RoSoI v_rosoi := { { 2, 4, 8, 16 } };
+ var template RoMyUnion vt_rouni := { { soi := { 1, 1, 1 } }, { soi := { -1, -3, -5 } } };
+ var template RoRoI vt_roroi := { { 10, 11 }, { 20, 26, 29 }, { 31, 33 } };
+
+ // templates with 'all from'
+ var template integer vt_sr := ( 0, all from v_rec.soi, all from vt_roroi[1] );
+ var template integer vt_sr_exp := ( 0, 7, 1, 5, 20, 26, 29 );
+ var template RoI vt_sr_perm := { permutation ( 3, all from v_rec.roi, all from vt_rouni[1].soi ) };
+ var template RoI vt_sr_perm_exp := { permutation ( 3, 2, 1, 0, -1, -3, -5 ) };
+ var template SoI vt_sr_sub := subset ( all from v_rosoi[0], 6, all from vt_roroi[0] );
+ var template SoI vt_sr_sub_exp := subset ( 2, 4, 8, 16, 6, 10, 11 );
+ var template SoI vt_sr_super := superset ( all from vt_rouni[0].soi, all from vt_rouni[0].soi );
+ var template SoI vt_sr_super_exp := superset ( 1, 1, 1, 1, 1, 1 );
+
+ // test templates with 'all from' against the expected templates
+ if (log2str(vt_sr) != log2str(vt_sr_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_exp, ", got: ", vt_sr);
+ }
+ if (log2str(vt_sr_perm) != log2str(vt_sr_perm_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_perm_exp, ", got: ", vt_sr_perm);
+ }
+ if (log2str(vt_sr_sub) != log2str(vt_sr_sub_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_sub_exp, ", got: ", vt_sr_sub);
+ }
+ if (log2str(vt_sr_super) != log2str(vt_sr_super_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_super_exp, ", got: ", vt_sr_super);
+ }
+ setverdict(pass);
+}
+
+// all from + module parameters
+modulepar MyRecord mp_rec := { i := omit, roi := { 2, 1, 0 }, soi := { 7, 1, 5 } };
+modulepar RoSoI mp_rosoi := { { 2, 4, 8, 16 } };
+modulepar template RoMyUnion mpt_rouni := { { soi := { 1, 1, 1 } }, { soi := { -1, -3, -5 } } };
+modulepar template RoRoI mpt_roroi := { { 10, 11 }, { 20, 26, 29 }, { 31, 33 } };
+
+testcase tc_all_from_subrefs_modulepar() runs on A
+{
+ // templates with 'all from'
+ var template integer vt_sr := ( 0, all from mp_rec.soi, all from mpt_roroi[1] );
+ var template integer vt_sr_exp := ( 0, 7, 1, 5, 20, 26, 29 );
+ var template RoI vt_sr_perm := { permutation ( 3, all from mp_rec.roi, all from mpt_rouni[1].soi ) };
+ var template RoI vt_sr_perm_exp := { permutation ( 3, 2, 1, 0, -1, -3, -5 ) };
+ var template SoI vt_sr_sub := subset ( all from mp_rosoi[0], 6, all from mpt_roroi[0] );
+ var template SoI vt_sr_sub_exp := subset ( 2, 4, 8, 16, 6, 10, 11 );
+ var template SoI vt_sr_super := superset ( all from mpt_rouni[0].soi, all from mpt_rouni[0].soi );
+ var template SoI vt_sr_super_exp := superset ( 1, 1, 1, 1, 1, 1 );
+
+ // test templates with 'all from' against the expected templates
+ if (log2str(vt_sr) != log2str(vt_sr_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_exp, ", got: ", vt_sr);
+ }
+ if (log2str(vt_sr_perm) != log2str(vt_sr_perm_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_perm_exp, ", got: ", vt_sr_perm);
+ }
+ if (log2str(vt_sr_sub) != log2str(vt_sr_sub_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_sub_exp, ", got: ", vt_sr_sub);
+ }
+ if (log2str(vt_sr_super) != log2str(vt_sr_super_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_super_exp, ", got: ", vt_sr_super);
+ }
+ setverdict(pass);
+}
+
+// all from + function parameters
+function f_test_all_from_param(RoMyRec p_rorec, in RoMyUnion p_rouni, inout MyUnion p_uni,
+ template RoSoI pt_rosoi, in template RoRoI pt_roroi, inout template MyRecord pt_rec)
+{
+ // templates with 'all from'
+ var template integer vt_sr := ( all from p_rorec[0].roi, 0, all from pt_rec.roi );
+ var template integer vt_sr_exp := ( -1, -3, -5, 0, 1, 3, 5 );
+ var template RoI vt_sr_perm := { permutation ( all from pt_rosoi[0], all from p_rouni[0].roi ) };
+ var template RoI vt_sr_perm_exp := { permutation ( 10, 20, 30, 11, 22, 33 ) };
+ var template SoI vt_sr_sub := subset ( all from p_uni.roi, all from p_uni.roi );
+ var template SoI vt_sr_sub_exp := subset ( 7, 77, 777, 7, 77, 777 );
+ var template SoI vt_sr_super := superset ( 0, all from pt_roroi[0], all from pt_roroi[1] );
+ var template SoI vt_sr_super_exp := superset ( 0, 1, 2, 3, 4, 5 );
+
+ // test templates with 'all from' against the expected templates
+ if (log2str(vt_sr) != log2str(vt_sr_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_exp, ", got: ", vt_sr);
+ }
+ if (log2str(vt_sr_perm) != log2str(vt_sr_perm_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_perm_exp, ", got: ", vt_sr_perm);
+ }
+ if (log2str(vt_sr_sub) != log2str(vt_sr_sub_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_sub_exp, ", got: ", vt_sr_sub);
+ }
+ if (log2str(vt_sr_super) != log2str(vt_sr_super_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_super_exp, ", got: ", vt_sr_super);
+ }
+ setverdict(pass);
+}
+
+testcase tc_all_from_subrefs_param() runs on A
+{
+ var MyUnion v_uni := c_uni;
+ var template MyRecord vt_rec := t_rec;
+ f_test_all_from_param(c_rorec, c_rouni, v_uni, t_rosoi(100), t_roroi, vt_rec);
+}
+
+// all from + function calls
+function f_rorec() return RoMyRec { return c_rorec; }
+function f_rouni() return RoMyUnion { return c_rouni; }
+function f_uni() return MyUnion { return c_uni; }
+function f_rosoi(in integer x) return template RoSoI { return t_rosoi(x); }
+function f_roroi() return template RoRoI { return t_roroi; }
+function f_rec() return template MyRecord { return t_rec; }
+
+testcase tc_all_from_subrefs_function() runs on A
+{
+ // templates with 'all from'
+ var template integer vt_sr := ( all from f_rorec()[0].roi, 0, all from f_rec().roi );
+ var template integer vt_sr_exp := ( -1, -3, -5, 0, 1, 3, 5 );
+ var template RoI vt_sr_perm := { permutation ( all from f_rosoi(100)[0], all from f_rouni()[0].roi ) };
+ var template RoI vt_sr_perm_exp := { permutation ( 10, 20, 30, 11, 22, 33 ) };
+ var template SoI vt_sr_sub := subset ( all from f_uni().roi, all from f_uni().roi );
+ var template SoI vt_sr_sub_exp := subset ( 7, 77, 777, 7, 77, 777 );
+ var template SoI vt_sr_super := superset ( 0, all from f_roroi()[0], all from f_roroi()[1] );
+ var template SoI vt_sr_super_exp := superset ( 0, 1, 2, 3, 4, 5 );
+
+ // test templates with 'all from' against the expected templates
+ if (log2str(vt_sr) != log2str(vt_sr_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_exp, ", got: ", vt_sr);
+ }
+ if (log2str(vt_sr_perm) != log2str(vt_sr_perm_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_perm_exp, ", got: ", vt_sr_perm);
+ }
+ if (log2str(vt_sr_sub) != log2str(vt_sr_sub_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_sub_exp, ", got: ", vt_sr_sub);
+ }
+ if (log2str(vt_sr_super) != log2str(vt_sr_super_exp)) {
+ setverdict(fail, "Expected: ", vt_sr_super_exp, ", got: ", vt_sr_super);
+ }
+ setverdict(pass);
+}
+
+control {
+ execute(tc_all_from_subrefs());
+ execute(tc_all_from_subrefs_permutation());
+ execute(tc_all_from_subrefs_subset());
+ execute(tc_all_from_subrefs_superset());
+ execute(tc_all_from_subrefs_var());
+ execute(tc_all_from_subrefs_modulepar());
+ execute(tc_all_from_subrefs_param());
+ execute(tc_all_from_subrefs_function());
+}
+
+}
diff --git a/Regression_Test_java/src/all_from/all_from_subset.ttcn b/Regression_Test_java/src/all_from/all_from_subset.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..45f976f7fa991f0424cd7067ab4b854b9e26dde8
--- /dev/null
+++ b/Regression_Test_java/src/all_from/all_from_subset.ttcn
@@ -0,0 +1,2846 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module all_from_subset
+{
+import from types all;
+import from functions all;
+
+template RoI t_imported_RoI1 := {1, 2, (6..9)};
+template RoI t_imported_RoI2 := {1, *, 3};
+template RoI t_imported_RoI3 := {20,21,22};
+template RoI t_imported_RoI4 := {1, ?, 3};
+//for permutation:
+template RoI t_imported_RoI1_P := {1, 2, *};
+template RoI t_imported_RoI3_P := {1, 2, 3};
+template RoI t_imported_RoI7_P := {1, 2, ?};
+
+//===========Set of Integer================================
+template SoI t_imported_SoI1 := {1,2,(6..9)};
+template SoI t_imported_SoI2 := {1, *, 3};
+template SoI t_imported_SoI3 := {20,21,22};
+
+// Test Target:
+// ETSI ES 201 873-1 v?.?
+// B.1.2.7 SubSet
+//just to test these types as well:
+modulepar RoI tsp_RoI3 := {20,21,22};
+modulepar RoI tsp_SoI3 := {20,21,22};
+
+const RoI c_RoI3 := {20,21,22};
+const SoI c_SoI3 := {20,21,22};
+
+group Csaba_group {
+ //template RoI t_RoI1 := {1, 2, (6..9)};
+ //template RoI t_RoI2 := {1, *, 3};
+
+ // B.1.2.7 SubSet
+ //EXAMPLE 1:
+ template MySetOfType MyTemplate1_ := subset (1, 2, 3);
+ // matches any sequence of integers which contains zero or one occurrences of the numbers
+ // 1, 2 and 3 in any order and position
+
+ template MySetOfType MyTemplate2_ := subset (1, 2, ?);
+ // matches any sequence of integers which contains zero or one occurrences of the numbers
+ // 1, 2 and a valid integer value (i.e. between 0 and 10, inclusive) in any order and position
+
+ template MySetOfType MyTemplate3_ := subset (1, 2, (3, 4));
+ // matches any sequence of integers which contains zero or one occurrences of the numbers
+ // 1, 2 and one of the numbers 3 or 4, in any order and position
+
+ template MySetOfType MyTemplate4_ := subset (1, 2, complement (3, 4));
+ // matches any sequence of integers which contains zero or one occurrences of the numbers
+ // 1, 2 and a valid integer number which is not 3 or 4, in any order and position
+
+ template MySetOfType MyTemplate5_ := subset (1, 2, 3) length (2);
+ // matches any sequence of two integers which contains zero or one occurrences of
+ // the numbers 1, 2 and 3, in any order and position
+
+ template MySetOfType MyTemplate6_ := subset (1, 2, ?) length (0 .. 2);
+ // matches any sequence of zero, one or two integers which contains zero or one occurrences of
+ // the numbers 1, 2 and of a valid integer value, in any order and position
+
+ template MySetOfType MyTemplate7_ := subset (1, 2, 3) length (0 .. 4);
+ // causes an error, the upper bound of length attribute contradicts to the maximum number of
+ // elements imposed by the subset argument
+
+ //EXAMPLE 2:
+ template RoI t_RoI1_ := {1, 2, ?};
+ template SoI t_SoI1_ := subset(all from t_RoI1_);
+ // results in subset(1, 2, ?)
+
+ testcase tc_subset() runs on A
+ {
+ action("subset: ", t_SoI1_);
+ var SoI v;
+
+ v := {};
+ if (match(v, t_SoI1_)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_SoI1_); }
+
+ v := { 1 };
+ if (match(v, t_SoI1_)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_SoI1_); }
+
+ v := { 2 };
+ if (match(v, t_SoI1_)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_SoI1_); }
+
+ v := { 42 };
+ if (match(v, t_SoI1_)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_SoI1_); }
+
+ v := { 1, 2, 3 };
+ if (match(v, t_SoI1_)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_SoI1_); }
+
+ v := { 1, 2, 3, 4, 5 };
+ if (not match(v, t_SoI1_)) { setverdict(pass); }
+ else { setverdict(fail, v, " should NOT match ", t_SoI1_); }
+ }
+
+}
+//Testcases by ethbaat:
+
+group Attilas_group {
+
+ //=============== Templates ==========================
+
+ //record of integers
+ template RoI t_RoI1 := {1, 2, (6..9)};
+ //template RoI t_RoI2 := {1, *, 3};
+ template RoI t_RoI3 := {20,21,22};
+ template RoI t_RoI4 := {1,2,?};
+ template RoI t_RoI5 := {1,2};
+ //SubSet of Integers
+ template SoI t_soi0 := subset (all from t_RoI3 );
+ template SoI t_soi0_eq := subset (20,21,22);
+ template SoI t_soi0_1 := subset ((all from t_RoI3 ));//i.e.: subset((20,21,22)); -it worked!
+ template SoI t_soi0_1_eq := subset ((20,21,22));
+ template SoI t_soi1 := subset (all from t_RoI1, 100);
+ template SoI t_soi1_eq := subset ( 1, 2, (6..9), 100);
+ template SoI t_soi2 := subset (-1,0,all from t_RoI1,100);
+ template SoI t_soi2_eq := subset (-1,0,1,2,(6..9),100);
+ template SoI t_soi3 := subset(-1,0,all from t_RoI1, all from t_RoI3,100);
+ template SoI t_soi3_eq := subset(-1,0,1,2,(6..9),20,21,22,100);
+ template SoI t_soi4 := subset(-1,0,all from t_RoI1, 100, all from t_RoI3);
+ template SoI t_soi4_eq := subset(-1,0,1,2,(6..9),100,20,21,22);
+
+ template SoI t_soi5 := subset(-1,0,all from t_RoI1, 100, all from t_RoI3,all from t_RoI3 ); //repetition
+ template SoI t_soi5_eq := subset(-1,0,1,2,(6..9),100,20,21,22,20,21,22);
+
+ template SoI t_soi6 := subset(-1,0,all from t_RoI1, 100, all from t_RoI3,all from t_RoI3,all from t_RoI3); //repetition
+ template SoI t_soi6_eq := subset(-1,0,1,2,(6..9),100,20,21,22,20,21,22,20,21,22);
+
+ template SoI t_soi7 := subset(all from t_RoI1) length (2);
+ template SoI t_soi7_eq := subset (1,2,(6..9)) length (2)
+
+ template SoI t_soi8 := subset(all from t_RoI1, complement(8,9)) length (2);
+ template SoI t_soi8_eq := subset (1,2,(6..9),complement(8,9)) length (2)
+
+ template SoI t_soi9 := subset(complement(all from t_RoI1)) ;
+ template SoI t_soi9_eq := subset (complement(1,2,(6..9))); //subset(-infinity..1,4,5,10,11,12,..}
+
+ template SoI t_soi10 := subset(all from t_RoI1, complement(all from t_RoI1)) length (2);
+ template SoI t_soi10_eq := subset (1,2,(6..9),complement(1,2,(6..9))) length (2);
+ template SoI t_soi11 := subset(all from t_RoI1, complement(all from t_RoI5)) length (2);
+ template SoI t_soi11_eq := subset(1, 2, (6..9) , complement(1,2)) length (2);
+
+ template SoI t_soi12 := subset(all from t_RoI4);
+ template SoI t_soi12_eq := subset(1, 2, ?);
+
+ //template SoI t_soi13s := subset(all from t_SoI2);
+ //template SoI t_soi13s_eq := subset(1,*,3);
+
+ //from modulepar:
+ template SoI t_soi13roi := subset(all from tsp_RoI3);
+ template SoI t_soi13_eq := subset(20,21,22);
+ template SoI t_soi13soi := subset(all from tsp_SoI3);
+
+ //from const:
+ template SoI t_soi13roi_c :=subset(all from c_RoI3);
+ template SoI t_soi13soi_c :=subset(all from c_SoI3);
+
+
+ //=== subset referring remote templates (imported templates)
+ template SoI t_importing_i0 := subset (all from t_imported_RoI3 );
+ template SoI t_importing_i0_1 := subset ((all from t_imported_RoI3 ));
+ template SoI t_importing_i1 := subset (all from t_imported_RoI1, 100);
+ template SoI t_importing_i2 := subset (-1,0,all from t_imported_RoI1,100);
+
+ //========== set of integers ==================
+ template SoI t_SoI1 := {1, 2, (6..9)};
+ //template SoI t_SoI2 := {1, *, 3};
+ template SoI t_SoI3 := {20,21,22};
+ template SoI t_SoI4 := {1,2,?};
+ template SoI t_SoI5 := {1,2};
+ //SubSet of Integers
+ template SoI t_soi0s := subset (all from t_SoI3 );
+ template SoI t_soi0s_eq := subset (20,21,22);
+ template SoI t_soi0s_1 := subset ((all from t_SoI3 ));//i.e.: subset((20,21,22)); -it worked!
+ template SoI t_soi0s_1_eq := subset ((20,21,22));
+ template SoI t_soi1s := subset (all from t_SoI1, 100);
+ template SoI t_soi1s_eq := subset ( 1, 2, (6..9), 100);
+ template SoI t_soi2s := subset (-1,0,all from t_SoI1,100);
+ template SoI t_soi2s_eq := subset (-1,0,1,2,(6..9),100);
+ template SoI t_soi3s := subset(-1,0,all from t_SoI1, all from t_SoI3,100);
+ template SoI t_soi3s_eq := subset(-1,0,1,2,(6..9),20,21,22,100);
+ template SoI t_soi4s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3);
+ template SoI t_soi4s_eq := subset(-1,0,1,2,(6..9),100,20,21,22);
+
+ template SoI t_soi5s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3 ); //repetition
+ template SoI t_soi5s_eq := subset(-1,0,1,2,(6..9),100,20,21,22,20,21,22);
+
+ template SoI t_soi6s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3,all from t_SoI3); //repetition
+ template SoI t_soi6s_eq := subset(-1,0,1,2,(6..9),100,20,21,22,20,21,22,20,21,22);
+
+ template SoI t_soi7s := subset(all from t_SoI1) length (2);
+ template SoI t_soi7s_eq := subset (1,2,(6..9)) length (2)
+
+ template SoI t_soi8s := subset(all from t_SoI1, complement(8,9)) length (2);
+ template SoI t_soi8s_eq := subset (1,2,(6..9),complement(8,9)) length (2)
+
+ template SoI t_soi9s := subset(complement(all from t_SoI1)) ;
+ template SoI t_soi9s_eq := subset (complement(1,2,(6..9))); //subset(-infinity..1,4,5,10,11,12,..}
+
+ template SoI t_soi10s := subset(all from t_SoI1, complement(all from t_SoI1)) length (2);
+ template SoI t_soi10s_eq := subset (1,2,(6..9),complement(1,2,(6..9))) length (2);
+ template SoI t_soi11s := subset(all from t_SoI1, complement(all from t_SoI5)) length (2);
+ template SoI t_soi11s_eq := subset(1, 2, (6..9) , complement(1,2)) length (2);
+
+ template SoI t_soi12s := subset(all from t_SoI4);
+ template SoI t_soi12s_eq := subset(1, 2, ?);
+
+ //template SoI t_soi13s := subset(all from t_SoI2);
+ //template SoI t_soi13s_eq := subset(1,*,3);
+
+ //================= Testcases ========================
+
+ //=============== Record of Integers ==================
+
+ //=== 0 ===
+ testcase tc_subset_soi0_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi0,t_soi0_eq);
+ }
+
+ testcase tc_subset_importing_i0_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_importing_i0,t_soi0_eq);
+ }
+ //t_i0:=subset (20,21,22)
+ testcase tc_subset_i0() runs on A {
+ var RoSoI vl_goodValues := {{},{20},{21},{22},{20,21},{22,20},{22,21},{20,21,22}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19}};
+ f_checkSoITemplate(t_soi0,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_importing_i0() runs on A {
+ var RoSoI vl_goodValues := {{},{20},{21},{22},{20,21},{22,20},{22,21},{20,21,22}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19}};
+ f_checkSoITemplate(t_importing_i0,vl_goodValues,vl_badValues);
+ }
+ //subset ((20,21,22));
+ testcase tc_subset_soi0_1_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi0_1,t_soi0_1_eq);
+ }
+
+ testcase tc_subset_importing_i0_1_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_importing_i0_1,t_soi0_1_eq);
+ }
+
+ testcase tc_subset_soi0_1() runs on A {
+ var RoSoI vl_goodValues := {{},{20},{21},{22} }
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,20},{20,21},{22,20},{22,21},{20,21,22},{20,21,22,21}};
+ // subset((20,21,22)) {this test} is not the same as subset(20,21,22) {previous test}
+ f_checkSoITemplate(t_soi0_1,vl_goodValues,vl_badValues);
+ }
+
+ //=== 1 ===
+ testcase tc_subset_soi1_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi1,t_soi1_eq);
+ }
+
+ testcase tc_subset_importing_i1_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_importing_i1,t_soi1_eq);
+ }
+ //t_i1={1,2,(6..9),100} - 2x2x5x2=40 good subsets
+ testcase tc_subset_i1() runs on A {
+ var RoSoI vl_goodValues := {
+ {},
+ {1},{2},{6},{7},{8},{9},{100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{0}, {-1},{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1}};
+ f_checkSoITemplate(t_soi1,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_importing_i1() runs on A {
+ var RoSoI vl_goodValues := {
+ {},
+ {1},{2},{6},{7},{8},{9},{100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{0}, {-1},{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1}};
+ f_checkSoITemplate(t_soi1,vl_goodValues,vl_badValues);
+ }
+ //=== 2 ===
+ testcase tc_subset_soi2_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi2,t_soi2_eq);
+ }
+
+ testcase tc_subset_importing_i2_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_importing_i2,t_soi2_eq);
+ }
+
+ testcase tc_subset_i2() runs on A {
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi2,vl_goodValues,vl_badValues);
+ }
+ //=== 3 ===
+ testcase tc_subset_soi3_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi3,t_soi3_eq);
+ }
+
+ testcase tc_subset_i3() runs on A {
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2, 20,21,22,100},{-1,0,1,2, 20,21,22,100},
+ {-1,0,1,2,8,20,21,22,100},{-1,0,1,2,8,20,21,22,100},{-1,0,1,2,9,20,21,22,100},
+ {-1,0,1,2,6,20,21,22,100},{-1,0,1,2,7,20,21,22,100},{-1,0,1,2,8,20,21,22,100},
+ {-1,0,1,2,9,20,21,22,100},{-1,0,1,2,20,21,22,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi3,vl_goodValues,vl_badValues);
+ }
+ //=== 4 ===
+ testcase tc_subset_soi4_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi4,t_soi4_eq);
+ }
+
+ testcase tc_subset_i4() runs on A {
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi4,vl_goodValues,vl_badValues);
+ }
+ //=== 5 ===
+ testcase tc_subset_soi5_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi5,t_soi5_eq);
+ }
+
+ testcase tc_subset_i5() runs on A {
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100},{-1,0,1,2,7,20,21,22,20,21,22,100},{-1,0,1,2,8,20,21,22,20,21,22,100},{-1,0,1,2,9,20,21,22,20,21,22,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100},
+ {-1,0,1,2,5,6,7,8,9,20,21,22,20,21,22,100},{-1,0,1,2,5,6,7,8,9,20,21,22,20,21,22,100,20}};
+ f_checkSoITemplate(t_soi5,vl_goodValues,vl_badValues);
+ }
+ //=== 6 ===
+ testcase tc_subset_soi6_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi6,t_soi6_eq);
+ }
+
+ testcase tc_subset_i6() runs on A {
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100},{-1,0,1,2,7,20,21,22,20,21,22,100},{-1,0,1,2,8,20,21,22,20,21,22,100},{-1,0,1,2,9,20,21,22,20,21,22,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100,20,22,21},
+ {-1,0,1,2,7,20,21,22,20,21,22,100,20,22,21},{-1,0,1,2,8,20,21,22,20,21,22,100,20,22,21}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100},
+ {-1,0,1,2,6,7,8,9,20,21,22,20,21,22,100,20,1,22,20},{1,2,200,1}};
+ f_checkSoITemplate(t_soi6,vl_goodValues,vl_badValues);
+ }
+ //=== 7 ===
+ testcase tc_subset_soi7_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi7,t_soi7_eq);
+ }
+
+ //subset (1,2,(6..9)) length (2)
+ testcase tc_subset_i7() runs on A {
+ var RoSoI vl_goodValues := {
+ {1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},
+ {1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi7,vl_goodValues,vl_badValues);
+ }
+ //=== 8 ===
+ testcase tc_subset_soi8_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi8,t_soi8_eq);
+ }
+
+ testcase tc_subset_i8() runs on A {
+ var RoSoI vl_goodValues := {
+ {1,1},{1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9},
+ {1,-1},{1,0},{1,1},{1,3},{1,4},{1,5},{1,10},{1,11},{1,100},
+ {2,-2},{2,-1},{2,0},{2,1},{2,2},{2,3},{2,4},{2,5},{2,10},{6,7},{6,10},
+ {7,7},{7,10},{7,11},
+ {8,6},{8,7},{8,10},{8,11},
+ {9,6},{9,7},{9,11}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi8,vl_goodValues,vl_badValues);
+ }
+ //=== 9 ===
+ testcase tc_subset_soi9_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi9,t_soi9_eq);
+ }
+
+ //subset(complement(1,2,(6..9))) == (-1, 0,3,4,5,10,11 )
+ testcase tc_subset_i9() runs on A {
+ var RoSoI vl_goodValues := { {}, {-2},{-1},{0},{3},{4},{5},{10},{11},{1000}};
+ var RoSoI vl_badValues := {
+ {1,-3},{1,-2},{1,-1},{1,0},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}, //...
+ {2,-3},{2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}, //...
+ {1},{2},{6},{7},{8},{9},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100},
+ {1,6,7,8,9}, {1,2,6,7,8,9},{-1,-2},{-1,-2,0},{-1,0,3,4,5,10,11}
+ };
+ f_checkSoITemplate(t_soi9,vl_goodValues,vl_badValues);
+ }
+ //=== 10 ===
+ testcase tc_subset_soi10_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi10,t_soi10_eq);
+ }
+
+ //t_i10=subset(1, 2, (6..9),complement(1, 2, (6..9)))
+ testcase tc_subset_i10() runs on A {
+ var RoSoI vl_goodValues := {
+ {1,-3},{1,-2},{1,-1},{1,0},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}, //...
+ {2,-3},{2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}, //...
+ {6,-3},{6,-2},{6,-1},{6,0},{6,3},{6,4}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{3},{4},{6},{7},{8},{9},{1000},{1,1},{2,2},{6,6},{6,9},{9,6},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi10,vl_goodValues,vl_badValues);
+ }
+ //=== 11 ===
+ testcase tc_subset_soi11_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi11,t_soi11_eq);
+ }
+
+ //t_i11=subset( 1,2,(6..9),complement(1,2))
+ testcase tc_subset_i11() runs on A {
+ var RoSoI vl_goodValues := {
+ {1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9},
+ {1,-1},{1,0},{1,3},{1,4},{1,5},{1,10},{1,11},{1,100},
+ {2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,10},{6,7},{6,10},
+ {7,7},{7,10},{7,11},
+ {8,6},{8,7},{8,10},{8,11},{6,6},
+ {9,6},{9,7},{9,11}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},{1,1},{2,2},{6,6,7},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi11,vl_goodValues,vl_badValues);
+ }
+
+ //=== i12 ===
+ //subset(1, 2, ?);
+ testcase tc_subset_soi12_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi12,t_soi12_eq);
+ }
+
+ testcase tc_subset_i12() runs on A {
+ var RoSoI vl_goodValues := {
+ {},{1},{2},{3},{4},{5},{6},
+ {1,1},{1,2},{1,3},{1,4},{1,6},
+ {2,3},{2,4},{2,5},{2,6},{2,7},
+ {1,2,3},{1,2,4},{1,2,5},{3,2,1},{3,1,2}
+ }
+ var RoSoI vl_badValues := {
+ {1,1,1}, {1,3,4},{1,3,5},{1,3,6},{1,2,3,4}
+ };
+ f_checkSoITemplate(t_soi12,vl_goodValues,vl_badValues);
+ }
+
+ //===i13===
+ //subset(1, *, 3);
+ /*
+ testcase tc_subset_soi13_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi13s,t_soi13s_eq);
+ }
+
+ testcase tc_subset_i13() runs on A {
+ var RoSoI vl_goodValues := {
+ {},{1},{2},{3},{4},{5},{6},
+ {1,1},{1,2},{1,3},{1,4},{1,6},
+ {2,3},{2,4},{2,5},{2,6},{2,7},
+ {1,2,3},{1,2,4},{1,2,5},{3,2,1},{3,1,2}
+ }
+ var RoSoI vl_badValues := {
+ {1,1,1}, {1,3,4},{1,3,5},{1,3,6},{1,2,3,4}
+ };
+ f_checkSoITemplate(t_soi13s,vl_goodValues,vl_badValues);
+ } */
+
+ //=== i13 ===
+ //modulepar, const
+
+ testcase tc_subset_soi13roi_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi13roi,t_soi13_eq);
+ }
+
+ testcase tc_subset_soi13roi() runs on A {
+ var RoSoI vl_goodValues := {
+ {},{20},{21},{22},{20,21},{21,20},{21,22},
+ {20,21,22},{21,20,22}
+ }
+ var RoSoI vl_badValues := {
+ {1,1,1}, {1,3,4},{1,3,5},{1,3,6},{1,2,3,4}
+ };
+ f_checkSoITemplate(t_soi13roi,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi13roi_c_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi13roi_c,t_soi13_eq);
+ }
+
+ testcase tc_subset_soi13roi_c() runs on A {
+ var RoSoI vl_goodValues := {
+ {},{20},{21},{22},{20,21},{21,20},{21,22},
+ {20,21,22},{21,20,22}
+ }
+ var RoSoI vl_badValues := {
+ {1,1,1}, {1,3,4},{1,3,5},{1,3,6},{1,2,3,4}
+ };
+ f_checkSoITemplate(t_soi13roi_c,vl_goodValues,vl_badValues);
+ }
+ //========== (The Same) Testcases for Dynamic Templates================
+
+
+ //=== i0 ===
+ testcase tc_subset_soi0_eq_dyn() runs on A {
+ var template SoI tl_i0s := subset (all from t_SoI3 );
+ f_checkSoITemplateEquivalence(tl_i0s,t_soi0s_eq);
+ }
+
+ //double dyn: source and result are dynamic:
+ testcase tc_subset_soi0_eq_2dyn() runs on A {
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i0s := subset (all from tl_SoI3 );
+ f_checkSoITemplateEquivalence(tl_i0s,t_soi0s_eq);
+ }
+
+ testcase tc_subset_soi0_dyn() runs on A {
+ var template SoI tl_i0s := subset (all from t_SoI3 );
+ var RoSoI vl_goodValues := {{},{20},{21},{22},{20,21},{22,20},{22,21},{20,21,22}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19}};
+ f_checkSoITemplate(tl_i0s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi0_2dyn() runs on A {
+ var template SoI tl_i0s := subset (all from t_SoI3 );
+ var RoSoI vl_goodValues := {{},{20},{21},{22},{20,21},{22,20},{22,21},{20,21,22}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19}};
+ f_checkSoITemplate(tl_i0s,vl_goodValues,vl_badValues);
+ }
+
+ //=== i1 ===
+ testcase tc_subset_soi1_eq_dyn() runs on A {
+ var template SoI tl_i1s := subset (all from t_SoI1, 100);
+ f_checkSoITemplateEquivalence(tl_i1s,t_soi1s_eq);
+ }
+
+ testcase tc_subset_soi1_eq_2dyn() runs on A {
+ template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i1s := subset (all from tl_SoI1, 100);
+ f_checkSoITemplateEquivalence(tl_i1s,t_soi1s_eq);
+ }
+
+ testcase tc_subset_soi1_dyn() runs on A {
+ var template SoI tl_i1s := subset (all from t_SoI1, 100);
+ var RoSoI vl_goodValues := {
+ {},
+ {1},{2},{6},{7},{8},{9},{100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{0}, {-1},{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1}};
+ f_checkSoITemplate(tl_i1s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi1_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i1s := subset (all from tl_SoI1, 100);
+ var RoSoI vl_goodValues := {
+ {},
+ {1},{2},{6},{7},{8},{9},{100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{0}, {-1},{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1}};
+ f_checkSoITemplate(tl_i1s,vl_goodValues,vl_badValues);
+ }
+
+ //=== i2 ===
+ testcase tc_subset_soi2_eq_dyn() runs on A {
+ var template SoI vt_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i2s := subset (-1,0,all from vt_SoI1,100);
+ f_checkSoITemplateEquivalence(tl_i2s,t_soi2s_eq);
+
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i2s,vl_goodValues,vl_badValues);
+
+ }
+
+ testcase tc_subset_soi2_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i2s := subset (-1,0,all from tl_SoI1,100);
+ f_checkSoITemplateEquivalence(tl_i2s,t_soi2s_eq);
+ }
+
+ testcase tc_subset_soi2_dyn() runs on A {
+ var template SoI tl_i2s := subset (-1,0,all from t_SoI1,100);
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i2s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi2_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i2s := subset (-1,0,all from t_SoI1,100);
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i2s,vl_goodValues,vl_badValues);
+ }
+
+ //=== i3 ===
+ testcase tc_subset_soi3_eq_dyn() runs on A {
+ var template SoI tl_i3s := subset(-1,0,all from t_SoI1, all from t_SoI3,100);
+ f_checkSoITemplateEquivalence(tl_i3s,t_soi3s_eq);
+ }
+
+ testcase tc_subset_soi3_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i3s := subset(-1,0,all from tl_SoI1, all from tl_SoI3,100);
+ f_checkSoITemplateEquivalence(tl_i3s,t_soi3s_eq);
+ }
+
+ testcase tc_subset_soi3_dyn() runs on A {
+ var template SoI tl_i3s := subset(-1,0,all from t_SoI1, all from t_SoI3,100);
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2, 20,21,22,100},{-1,0,1,2, 20,21,22,100},
+ {-1,0,1,2,8,20,21,22,100},{-1,0,1,2,8,20,21,22,100},{-1,0,1,2,9,20,21,22,100},
+ {-1,0,1,2,6,20,21,22,100},{-1,0,1,2,7,20,21,22,100},{-1,0,1,2,8,20,21,22,100},
+ {-1,0,1,2,9,20,21,22,100},{-1,0,1,2,20,21,22,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i3s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi3_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i3s := subset(-1,0,all from tl_SoI1, all from tl_SoI3,100);
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2, 20,21,22,100},{-1,0,1,2, 20,21,22,100},
+ {-1,0,1,2,8,20,21,22,100},{-1,0,1,2,8,20,21,22,100},{-1,0,1,2,9,20,21,22,100},
+ {-1,0,1,2,6,20,21,22,100},{-1,0,1,2,7,20,21,22,100},{-1,0,1,2,8,20,21,22,100},
+ {-1,0,1,2,9,20,21,22,100},{-1,0,1,2,20,21,22,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i3s,vl_goodValues,vl_badValues);
+ }
+
+ //=== i4 ===
+ testcase tc_subset_soi4_eq_dyn() runs on A {
+ var template SoI tl_i4s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3);
+ f_checkSoITemplateEquivalence(tl_i4s,t_soi4s_eq);
+ }
+
+ testcase tc_subset_soi4_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i4s := subset(-1,0,all from tl_SoI1, 100, all from tl_SoI3);
+ f_checkSoITemplateEquivalence(tl_i4s,t_soi4s_eq);
+ }
+
+ testcase tc_subset_soi4_dyn() runs on A {
+ var template SoI tl_i4s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3);
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i4s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi4_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i4s := subset(-1,0,all from tl_SoI1, 100, all from tl_SoI3);
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i4s,vl_goodValues,vl_badValues);
+ }
+
+
+ //=== i5 ===
+ testcase tc_subset_soi5_eq_dyn() runs on A {
+ var template SoI tl_i5s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3 ); //repetition
+ f_checkSoITemplateEquivalence(tl_i5s,t_soi5s_eq);
+ }
+
+ testcase tc_subset_soi5_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i5s := subset(-1,0,all from tl_SoI1, 100, all from tl_SoI3,all from tl_SoI3 ); //repetition
+ f_checkSoITemplateEquivalence(tl_i5s,t_soi5s_eq);
+ }
+
+ testcase tc_subset_soi5_dyn() runs on A {
+ var template SoI tl_i5s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3 ); //repetition
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100},{-1,0,1,2,7,20,21,22,20,21,22,100},{-1,0,1,2,8,20,21,22,20,21,22,100},{-1,0,1,2,9,20,21,22,20,21,22,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100},
+ {-1,0,1,2,5,6,7,8,9,20,21,22,20,21,22,100},{-1,0,1,2,5,6,7,8,9,20,21,22,20,21,22,100,20}};
+ f_checkSoITemplate(tl_i5s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi5_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i5s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3 ); //repetition
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100},{-1,0,1,2,7,20,21,22,20,21,22,100},{-1,0,1,2,8,20,21,22,20,21,22,100},{-1,0,1,2,9,20,21,22,20,21,22,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100},
+ {-1,0,1,2,5,6,7,8,9,20,21,22,20,21,22,100},{-1,0,1,2,5,6,7,8,9,20,21,22,20,21,22,100,20}};
+ f_checkSoITemplate(tl_i5s,vl_goodValues,vl_badValues);
+ }
+
+ //=== i6 =====
+ testcase tc_subset_soi6_eq_dyn() runs on A {
+ var template SoI tl_i6s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3,all from t_SoI3); //repetition
+ f_checkSoITemplateEquivalence(tl_i6s,t_soi6s_eq);
+ }
+
+ testcase tc_subset_soi6_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i6s := subset(-1,0,all from tl_SoI1, 100, all from tl_SoI3,all from tl_SoI3,all from tl_SoI3); //repetition
+ f_checkSoITemplateEquivalence(tl_i6s,t_soi6s_eq);
+ }
+
+ testcase tc_subset_soi6_dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i6s := subset(-1,0,all from tl_SoI1, 100, all from tl_SoI3,all from tl_SoI3,all from tl_SoI3); //repetition
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100},{-1,0,1,2,7,20,21,22,20,21,22,100},{-1,0,1,2,8,20,21,22,20,21,22,100},{-1,0,1,2,9,20,21,22,20,21,22,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100,20,22,21},
+ {-1,0,1,2,7,20,21,22,20,21,22,100,20,22,21},{-1,0,1,2,8,20,21,22,20,21,22,100,20,22,21}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100},
+ {-1,0,1,2,6,7,8,9,20,21,22,20,21,22,100,20,1,22,20},{1,2,200,1}};
+ f_checkSoITemplate(tl_i6s,vl_goodValues,vl_badValues);
+ }
+
+
+ //=== i7 =====
+ //subset (1,2,(6..9)) length (2)
+
+ testcase tc_subset_soi7_eq_dyn() runs on A {
+ var template SoI tl_i7s := subset(all from t_SoI1) length (2);
+ f_checkSoITemplateEquivalence(tl_i7s,t_soi7s_eq);
+ }
+
+ testcase tc_subset_soi7_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i7s := subset(all from tl_SoI1) length (2);
+ f_checkSoITemplateEquivalence(tl_i7s,t_soi7s_eq);
+ }
+
+ //subset (1,2,(6..9)) length (2)
+ testcase tc_subset_soi7_dyn() runs on A {
+ var template SoI tl_i7s := subset(all from t_SoI1) length (2);
+ var RoSoI vl_goodValues := {
+ {1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},
+ {1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i7s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi7_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i7s := subset(all from tl_SoI1) length (2);
+ var RoSoI vl_goodValues := {
+ {1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},
+ {1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i7s,vl_goodValues,vl_badValues);
+ }
+ //=== i8 ===
+
+ testcase tc_subset_soi8_eq_dyn() runs on A {
+ var template SoI tl_i8s := subset(all from t_SoI1, complement(8,9)) length (2);
+ f_checkSoITemplateEquivalence(tl_i8s,t_soi8s_eq);
+ }
+
+ testcase tc_subset_soi8_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i8s := subset(all from tl_SoI1, complement(8,9)) length (2);
+ f_checkSoITemplateEquivalence(tl_i8s,t_soi8s_eq);
+ }
+
+ testcase tc_subset_soi8_dyn() runs on A {
+ var template SoI tl_i8s := subset(all from t_SoI1, complement(8,9)) length (2);
+ var RoSoI vl_goodValues := {
+ {1,1},{1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9},
+ {1,-1},{1,0},{1,1},{1,3},{1,4},{1,5},{1,10},{1,11},{1,100},
+ {2,-2},{2,-1},{2,0},{2,1},{2,2},{2,3},{2,4},{2,5},{2,10},{6,7},{6,10},
+ {7,7},{7,10},{7,11},
+ {8,6},{8,7},{8,10},{8,11},
+ {9,6},{9,7},{9,11}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i8s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi8_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i8s := subset(all from tl_SoI1, complement(8,9)) length (2);
+ var RoSoI vl_goodValues := {
+ {1,1},{1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9},
+ {1,-1},{1,0},{1,1},{1,3},{1,4},{1,5},{1,10},{1,11},{1,100},
+ {2,-2},{2,-1},{2,0},{2,1},{2,2},{2,3},{2,4},{2,5},{2,10},{6,7},{6,10},
+ {7,7},{7,10},{7,11},
+ {8,6},{8,7},{8,10},{8,11},
+ {9,6},{9,7},{9,11}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i8s,vl_goodValues,vl_badValues);
+ }
+
+ //===i9===
+
+ testcase tc_subset_soi9_eq_dyn() runs on A {
+ var template SoI tl_i9s := subset(complement(all from t_SoI1)) ;
+ f_checkSoITemplateEquivalence(tl_i9s,t_soi9s_eq);
+ }
+
+ testcase tc_subset_soi9_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i9s := subset(complement(all from tl_SoI1)) ;
+ f_checkSoITemplateEquivalence(tl_i9s,t_soi9s_eq);
+ }
+
+
+ //subset(complement(1,2,(6..9))) == (-1, 0,3,4,5,10,11 )
+ testcase tc_subset_soi9_dyn() runs on A {
+ var template SoI tl_i9s := subset(complement(all from t_SoI1)) ;
+ var RoSoI vl_goodValues := { {}, {-2},{-1},{0},{3},{4},{5},{10},{11},{1000}};
+ var RoSoI vl_badValues := {
+ {1,-3},{1,-2},{1,-1},{1,0},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}, //...
+ {2,-3},{2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}, //...
+ {1},{2},{6},{7},{8},{9},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100},
+ {1,6,7,8,9}, {1,2,6,7,8,9},{-1,-2},{-1,-2,0},{-1,0,3,4,5,10,11}
+ };
+ f_checkSoITemplate(tl_i9s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi9_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i9s := subset(complement(all from tl_SoI1)) ;
+ var RoSoI vl_goodValues := { {}, {-2},{-1},{0},{3},{4},{5},{10},{11},{1000}};
+ var RoSoI vl_badValues := {
+ {1,-3},{1,-2},{1,-1},{1,0},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}, //...
+ {2,-3},{2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}, //...
+ {1},{2},{6},{7},{8},{9},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100},
+ {1,6,7,8,9}, {1,2,6,7,8,9},{-1,-2},{-1,-2,0},{-1,0,3,4,5,10,11}
+ };
+ f_checkSoITemplate(tl_i9s,vl_goodValues,vl_badValues);
+ }
+
+ //===i10===
+
+ testcase tc_subset_soi10_eq_dyn() runs on A {
+ var template SoI tl_i10s := subset(all from t_SoI1, complement(all from t_SoI1)) length (2);
+ f_checkSoITemplateEquivalence(tl_i10s,t_soi10s_eq);
+ }
+
+ testcase tc_subset_soi10_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i10s := subset(all from tl_SoI1, complement(all from tl_SoI1)) length (2);
+ f_checkSoITemplateEquivalence(tl_i10s,t_soi10s_eq);
+ }
+
+
+ //t_soi10s=subset(1, 2, (6..9),complement(1, 2, (6..9)))
+ testcase tc_subset_soi10_dyn() runs on A {
+ var template SoI tl_i10s := subset(all from t_SoI1, complement(all from t_SoI1)) length (2);
+ var RoSoI vl_goodValues := {
+ {1,-3},{1,-2},{1,-1},{1,0},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}, //...
+ {2,-3},{2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}, //...
+ {6,-3},{6,-2},{6,-1},{6,0},{6,3},{6,4}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{3},{4},{6},{7},{8},{9},{1000},{1,1},{2,2},{6,6},{6,9},{9,6},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi10s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi10_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i10s := subset(all from tl_SoI1, complement(all from tl_SoI1)) length (2);
+ var RoSoI vl_goodValues := {
+ {1,-3},{1,-2},{1,-1},{1,0},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}, //...
+ {2,-3},{2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}, //...
+ {6,-3},{6,-2},{6,-1},{6,0},{6,3},{6,4}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{3},{4},{6},{7},{8},{9},{1000},{1,1},{2,2},{6,6},{6,9},{9,6},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi10s,vl_goodValues,vl_badValues);
+ }
+ //===i11===
+ testcase tc_subset_soi11_eq_dyn() runs on A {
+ template SoI tl_i11s := subset(all from t_SoI1, complement(all from t_SoI5)) length (2);
+ f_checkSoITemplateEquivalence(tl_i11s,t_soi11s_eq);
+ }
+
+ testcase tc_subset_soi11_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI5 := {1,2};
+ template SoI tl_i11s := subset(all from tl_SoI1, complement(all from tl_SoI5)) length (2);
+ f_checkSoITemplateEquivalence(tl_i11s,t_soi11s_eq);
+ }
+
+ //t_soi11s=subset( 1,2,(6..9),complement(1,2))
+ testcase tc_subset_soi11_dyn() runs on A {
+ template SoI tl_i11s := subset(all from t_SoI1, complement(all from t_SoI5)) length (2);
+ var RoSoI vl_goodValues := {
+ {1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9},
+ {1,-1},{1,0},{1,3},{1,4},{1,5},{1,10},{1,11},{1,100},
+ {2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,10},{6,7},{6,10},
+ {7,7},{7,10},{7,11},
+ {8,6},{8,7},{8,10},{8,11},{6,6},
+ {9,6},{9,7},{9,11}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},{1,1},{2,2},{6,6,7},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi11s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi11_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI5 := {1,2};
+ template SoI tl_i11s := subset(all from tl_SoI1, complement(all from tl_SoI5)) length (2);
+ var RoSoI vl_goodValues := {
+ {1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9},
+ {1,-1},{1,0},{1,3},{1,4},{1,5},{1,10},{1,11},{1,100},
+ {2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,10},{6,7},{6,10},
+ {7,7},{7,10},{7,11},
+ {8,6},{8,7},{8,10},{8,11},{6,6},
+ {9,6},{9,7},{9,11}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},{1,1},{2,2},{6,6,7},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi11s,vl_goodValues,vl_badValues);
+ }
+
+ //=== i12 ===
+ //subset(1, 2, ?);
+ testcase tc_subset_soi12_eq_dyn() runs on A {
+ var template SoI tl_i12s := subset(all from t_SoI4);
+ f_checkSoITemplateEquivalence(tl_i12s,t_soi12s_eq);
+ }
+
+ testcase tc_subset_soi12_eq_2dyn() runs on A {
+ var template SoI tl_SoI4 := {1,2,?};
+ var template SoI tl_i12s := subset(all from tl_SoI4);
+ f_checkSoITemplateEquivalence(tl_i12s,t_soi12s_eq);
+ }
+
+ testcase tc_subset_soi12_dyn() runs on A {
+ var template SoI tl_i12s := subset(all from t_SoI4);
+ var RoSoI vl_goodValues := {
+ {},{1},{2},{3},{4},{5},{6},
+ {1,1},{1,2},{1,3},{1,4},{1,6},
+ {2,3},{2,4},{2,5},{2,6},{2,7},
+ {1,2,3},{1,2,4},{1,2,5},{3,2,1},{3,1,2}
+ }
+ var RoSoI vl_badValues := {
+ {1,1,1}, {1,3,4},{1,3,5},{1,3,6},{1,2,3,4}
+ };
+ f_checkSoITemplate(tl_i12s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi12_2dyn() runs on A {
+ var template SoI tl_SoI4 := {1,2,?};
+ var template SoI tl_i12s := subset(all from tl_SoI4);
+ var RoSoI vl_goodValues := {
+ {},{1},{2},{3},{4},{5},{6},
+ {1,1},{1,2},{1,3},{1,4},{1,6},
+ {2,3},{2,4},{2,5},{2,6},{2,7},
+ {1,2,3},{1,2,4},{1,2,5},{3,2,1},{3,1,2}
+ }
+ var RoSoI vl_badValues := {
+ {1,1,1}, {1,3,4},{1,3,5},{1,3,6},{1,2,3,4}
+ };
+ f_checkSoITemplate(t_soi12s,vl_goodValues,vl_badValues);
+ }
+
+ //================== Set of Integers ==================
+ testcase tc_subset_soi0s_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi0s,t_soi0s_eq);
+ }
+
+ //t_soi0s:=subset (20,21,22)
+ testcase tc_subset_soi0s() runs on A {
+ var RoSoI vl_goodValues := {{},{20},{21},{22},{20,21},{22,20},{22,21},{20,21,22}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19}};
+ f_checkSoITemplate(t_soi0s,vl_goodValues,vl_badValues);
+ }
+
+ //subset ((20,21,22));
+ testcase tc_subset_soi0s_1_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi0s_1,t_soi0s_1_eq);
+ }
+ testcase tc_subset_soi0s_1() runs on A {
+ var RoSoI vl_goodValues := {{},{20},{21},{22} }
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,20},{20,21},{22,20},{22,21},{20,21,22},{20,21,22,21}};
+ // subset((20,21,22)) {this test} is not the same as subset(20,21,22) {previous test}
+ f_checkSoITemplate(t_soi0s_1,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi1ss_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi1s,t_soi1s_eq);
+ }
+ //t_soi1s={1,2,(6..9),100} - 2x2x5x2=40 good subsets
+ testcase tc_subset_soi1s() runs on A {
+ var RoSoI vl_goodValues := {
+ {},
+ {1},{2},{6},{7},{8},{9},{100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{0}, {-1},{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1}};
+ f_checkSoITemplate(t_soi1s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi2s_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi2s,t_soi2s_eq);
+ }
+
+ testcase tc_subset_soi2s() runs on A {
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi2s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi3s_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi3s,t_soi3s_eq);
+ }
+
+ testcase tc_subset_soi3s() runs on A {
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2, 20,21,22,100},{-1,0,1,2, 20,21,22,100},
+ {-1,0,1,2,8,20,21,22,100},{-1,0,1,2,8,20,21,22,100},{-1,0,1,2,9,20,21,22,100},
+ {-1,0,1,2,6,20,21,22,100},{-1,0,1,2,7,20,21,22,100},{-1,0,1,2,8,20,21,22,100},
+ {-1,0,1,2,9,20,21,22,100},{-1,0,1,2,20,21,22,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi3s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi4ss_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi4s,t_soi4s_eq);
+ }
+
+ testcase tc_subset_soi4s() runs on A {
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi4s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi5ss_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi5s,t_soi5s_eq);
+ }
+
+ testcase tc_subset_soi5s() runs on A {
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100},{-1,0,1,2,7,20,21,22,20,21,22,100},{-1,0,1,2,8,20,21,22,20,21,22,100},{-1,0,1,2,9,20,21,22,20,21,22,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100},
+ {-1,0,1,2,5,6,7,8,9,20,21,22,20,21,22,100},{-1,0,1,2,5,6,7,8,9,20,21,22,20,21,22,100,20}};
+ f_checkSoITemplate(t_soi5s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi6ss_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi6s,t_soi6s_eq);
+ }
+
+ testcase tc_subset_soi6s() runs on A {
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100},{-1,0,1,2,7,20,21,22,20,21,22,100},{-1,0,1,2,8,20,21,22,20,21,22,100},{-1,0,1,2,9,20,21,22,20,21,22,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100,20,22,21},
+ {-1,0,1,2,7,20,21,22,20,21,22,100,20,22,21},{-1,0,1,2,8,20,21,22,20,21,22,100,20,22,21}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100},
+ {-1,0,1,2,6,7,8,9,20,21,22,20,21,22,100,20,1,22,20},{1,2,200,1}};
+ f_checkSoITemplate(t_soi6s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi7ss_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi7s,t_soi7s_eq);
+ }
+
+ //subset (1,2,(6..9)) length (2)
+ testcase tc_subset_soi7s() runs on A {
+ var RoSoI vl_goodValues := {
+ {1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},
+ {1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi7s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi8ss_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi8s,t_soi8s_eq);
+ }
+
+ testcase tc_subset_soi8s() runs on A {
+ var RoSoI vl_goodValues := {
+ {1,1},{1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9},
+ {1,-1},{1,0},{1,1},{1,3},{1,4},{1,5},{1,10},{1,11},{1,100},
+ {2,-2},{2,-1},{2,0},{2,1},{2,2},{2,3},{2,4},{2,5},{2,10},{6,7},{6,10},
+ {7,7},{7,10},{7,11},
+ {8,6},{8,7},{8,10},{8,11},
+ {9,6},{9,7},{9,11}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi8s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi9ss_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi9s,t_soi9s_eq);
+ }
+
+ //subset(complement(1,2,(6..9))) == (-1, 0,3,4,5,10,11 )
+ testcase tc_subset_soi9s() runs on A {
+ var RoSoI vl_goodValues := { {}, {-2},{-1},{0},{3},{4},{5},{10},{11},{1000}};
+ var RoSoI vl_badValues := {
+ {1,-3},{1,-2},{1,-1},{1,0},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}, //...
+ {2,-3},{2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}, //...
+ {1},{2},{6},{7},{8},{9},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100},
+ {1,6,7,8,9}, {1,2,6,7,8,9},{-1,-2},{-1,-2,0},{-1,0,3,4,5,10,11}
+ };
+ f_checkSoITemplate(t_soi9s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi10ss_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi10s,t_soi10s_eq);
+ }
+
+ //t_soi10s=subset(1, 2, (6..9),complement(1, 2, (6..9)))
+ testcase tc_subset_soi10s() runs on A {
+ var RoSoI vl_goodValues := {
+ {1,-3},{1,-2},{1,-1},{1,0},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}, //...
+ {2,-3},{2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}, //...
+ {6,-3},{6,-2},{6,-1},{6,0},{6,3},{6,4}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{3},{4},{6},{7},{8},{9},{1000},{1,1},{2,2},{6,6},{6,9},{9,6},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi10s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi11s_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi11s,t_soi11s_eq);
+ }
+
+ //t_soi11s=subset( 1,2,(6..9),complement(1,2))
+ testcase tc_subset_soi11s() runs on A {
+ var RoSoI vl_goodValues := {
+ {1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9},
+ {1,-1},{1,0},{1,3},{1,4},{1,5},{1,10},{1,11},{1,100},
+ {2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,10},{6,7},{6,10},
+ {7,7},{7,10},{7,11},
+ {8,6},{8,7},{8,10},{8,11},{6,6},
+ {9,6},{9,7},{9,11}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},{1,1},{2,2},{6,6,7},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi11s,vl_goodValues,vl_badValues);
+ }
+
+ //===i12s===
+ //subset(1, 2, ?);
+ testcase tc_subset_soi12s_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi12s,t_soi12s_eq);
+ }
+
+ testcase tc_subset_soi12s() runs on A {
+ var RoSoI vl_goodValues := {
+ {},{1},{2},{3},{4},{5},{6},
+ {1,1},{1,2},{1,3},{1,4},{1,6},
+ {2,3},{2,4},{2,5},{2,6},{2,7},
+ {1,2,3},{1,2,4},{1,2,5},{3,2,1},{3,1,2}
+ }
+ var RoSoI vl_badValues := {
+ {1,1,1}, {1,3,4},{1,3,5},{1,3,6},{1,2,3,4}
+ };
+ f_checkSoITemplate(t_soi12s,vl_goodValues,vl_badValues);
+ }
+
+ //===i13===
+ //subset(1, *, 3);
+ /*
+ testcase tc_subset_soi13s_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_soi13s,t_soi13s_eq);
+ }
+
+ testcase tc_subset_soi13s() runs on A {
+ var RoSoI vl_goodValues := {
+ {},{1},{2},{3},{4},{5},{6},
+ {1,1},{1,2},{1,3},{1,4},{1,6},
+ {2,3},{2,4},{2,5},{2,6},{2,7},
+ {1,2,3},{1,2,4},{1,2,5},{3,2,1},{3,1,2}
+ }
+ var RoSoI vl_badValues := {
+ {1,1,1}, {1,3,4},{1,3,5},{1,3,6},{1,2,3,4}
+ };
+ f_checkSoITemplate(t_soi13s,vl_goodValues,vl_badValues);
+ } */
+
+
+
+
+ //========== (The Same) Testcases for Dynamic Templates================
+
+
+ //=== i0 ===
+ testcase tc_subset_soi0s_eq_dyn() runs on A {
+ var template SoI tl_i0s := subset (all from t_SoI3 );
+ f_checkSoITemplateEquivalence(tl_i0s,t_soi0s_eq);
+ }
+
+ //double dyn: source and result are dynamic:
+ testcase tc_subset_soi0s_eq_2dyn() runs on A {
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i0s := subset (all from tl_SoI3 );
+ f_checkSoITemplateEquivalence(tl_i0s,t_soi0s_eq);
+ }
+
+ testcase tc_subset_soi0s_dyn() runs on A {
+ var template SoI tl_i0s := subset (all from t_SoI3 );
+ var RoSoI vl_goodValues := {{},{20},{21},{22},{20,21},{22,20},{22,21},{20,21,22}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19}};
+ f_checkSoITemplate(tl_i0s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi0s_2dyn() runs on A {
+ var template SoI tl_i0s := subset (all from t_SoI3 );
+ var RoSoI vl_goodValues := {{},{20},{21},{22},{20,21},{22,20},{22,21},{20,21,22}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19}};
+ f_checkSoITemplate(tl_i0s,vl_goodValues,vl_badValues);
+ }
+
+ //=== i1 ===
+ testcase tc_subset_soi1s_eq_dyn() runs on A {
+ var template SoI tl_i1s := subset (all from t_SoI1, 100);
+ f_checkSoITemplateEquivalence(tl_i1s,t_soi1s_eq);
+ }
+
+ testcase tc_subset_soi1s_eq_2dyn() runs on A {
+ template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i1s := subset (all from tl_SoI1, 100);
+ f_checkSoITemplateEquivalence(tl_i1s,t_soi1s_eq);
+ }
+
+ testcase tc_subset_soi1s_dyn() runs on A {
+ var template SoI tl_i1s := subset (all from t_SoI1, 100);
+ var RoSoI vl_goodValues := {
+ {},
+ {1},{2},{6},{7},{8},{9},{100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{0}, {-1},{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1}};
+ f_checkSoITemplate(tl_i1s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi1s_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i1s := subset (all from tl_SoI1, 100);
+ var RoSoI vl_goodValues := {
+ {},
+ {1},{2},{6},{7},{8},{9},{100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{0}, {-1},{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1}};
+ f_checkSoITemplate(tl_i1s,vl_goodValues,vl_badValues);
+ }
+
+ //=== i2 ===
+ testcase tc_subset_soi2s_eq_dyn() runs on A {
+ var template SoI vt_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i2s := subset (-1,0,all from vt_SoI1,100);
+ f_checkSoITemplateEquivalence(tl_i2s,t_soi2s_eq);
+
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i2s,vl_goodValues,vl_badValues);
+
+ }
+
+ testcase tc_subset_soi2s_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i2s := subset (-1,0,all from tl_SoI1,100);
+ f_checkSoITemplateEquivalence(tl_i2s,t_soi2s_eq);
+ }
+
+ testcase tc_subset_soi2s_dyn() runs on A {
+ var template SoI tl_i2s := subset (-1,0,all from t_SoI1,100);
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i2s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi2s_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i2s := subset (-1,0,all from t_SoI1,100);
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i2s,vl_goodValues,vl_badValues);
+ }
+
+ //=== i3 ===
+ testcase tc_subset_soi3ss_eq_dyn() runs on A {
+ var template SoI tl_i3s := subset(-1,0,all from t_SoI1, all from t_SoI3,100);
+ f_checkSoITemplateEquivalence(tl_i3s,t_soi3s_eq);
+ }
+
+ testcase tc_subset_soi3ss_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i3s := subset(-1,0,all from tl_SoI1, all from tl_SoI3,100);
+ f_checkSoITemplateEquivalence(tl_i3s,t_soi3s_eq);
+ }
+
+ testcase tc_subset_soi3s_dyn() runs on A {
+ var template SoI tl_i3s := subset(-1,0,all from t_SoI1, all from t_SoI3,100);
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2, 20,21,22,100},{-1,0,1,2, 20,21,22,100},
+ {-1,0,1,2,8,20,21,22,100},{-1,0,1,2,8,20,21,22,100},{-1,0,1,2,9,20,21,22,100},
+ {-1,0,1,2,6,20,21,22,100},{-1,0,1,2,7,20,21,22,100},{-1,0,1,2,8,20,21,22,100},
+ {-1,0,1,2,9,20,21,22,100},{-1,0,1,2,20,21,22,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i3s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi3s_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i3s := subset(-1,0,all from tl_SoI1, all from tl_SoI3,100);
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2, 20,21,22,100},{-1,0,1,2, 20,21,22,100},
+ {-1,0,1,2,8,20,21,22,100},{-1,0,1,2,8,20,21,22,100},{-1,0,1,2,9,20,21,22,100},
+ {-1,0,1,2,6,20,21,22,100},{-1,0,1,2,7,20,21,22,100},{-1,0,1,2,8,20,21,22,100},
+ {-1,0,1,2,9,20,21,22,100},{-1,0,1,2,20,21,22,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i3s,vl_goodValues,vl_badValues);
+ }
+
+ //=== i4 ===
+ testcase tc_subset_soi4ss_eq_dyn() runs on A {
+ var template SoI tl_i4s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3);
+ f_checkSoITemplateEquivalence(tl_i4s,t_soi4s_eq);
+ }
+
+ testcase tc_subset_soi4ss_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i4s := subset(-1,0,all from tl_SoI1, 100, all from tl_SoI3);
+ f_checkSoITemplateEquivalence(tl_i4s,t_soi4s_eq);
+ }
+
+ testcase tc_subset_soi4s_dyn() runs on A {
+ var template SoI tl_i4s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3);
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i4s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi4s_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i4s := subset(-1,0,all from tl_SoI1, 100, all from tl_SoI3);
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i4s,vl_goodValues,vl_badValues);
+ }
+
+
+ //=== i5 ===
+ testcase tc_subset_soi5ss_eq_dyn() runs on A {
+ var template SoI tl_i5s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3 ); //repetition
+ f_checkSoITemplateEquivalence(tl_i5s,t_soi5s_eq);
+ }
+
+ testcase tc_subset_soi5ss_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i5s := subset(-1,0,all from tl_SoI1, 100, all from tl_SoI3,all from tl_SoI3 ); //repetition
+ f_checkSoITemplateEquivalence(tl_i5s,t_soi5s_eq);
+ }
+
+ testcase tc_subset_soi5s_dyn() runs on A {
+ var template SoI tl_i5s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3 ); //repetition
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100},{-1,0,1,2,7,20,21,22,20,21,22,100},{-1,0,1,2,8,20,21,22,20,21,22,100},{-1,0,1,2,9,20,21,22,20,21,22,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100},
+ {-1,0,1,2,5,6,7,8,9,20,21,22,20,21,22,100},{-1,0,1,2,5,6,7,8,9,20,21,22,20,21,22,100,20}};
+ f_checkSoITemplate(tl_i5s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi5s_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i5s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3 ); //repetition
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100},{-1,0,1,2,7,20,21,22,20,21,22,100},{-1,0,1,2,8,20,21,22,20,21,22,100},{-1,0,1,2,9,20,21,22,20,21,22,100}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100},
+ {-1,0,1,2,5,6,7,8,9,20,21,22,20,21,22,100},{-1,0,1,2,5,6,7,8,9,20,21,22,20,21,22,100,20}};
+ f_checkSoITemplate(tl_i5s,vl_goodValues,vl_badValues);
+ }
+
+ //=== i6 =====
+ testcase tc_subset_soi6ss_eq_dyn() runs on A {
+ var template SoI tl_i6s := subset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3,all from t_SoI3); //repetition
+ f_checkSoITemplateEquivalence(tl_i6s,t_soi6s_eq);
+ }
+
+ testcase tc_subset_soi6ss_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i6s := subset(-1,0,all from tl_SoI1, 100, all from tl_SoI3,all from tl_SoI3,all from tl_SoI3); //repetition
+ f_checkSoITemplateEquivalence(tl_i6s,t_soi6s_eq);
+ }
+
+ testcase tc_subset_soi6s_dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i6s := subset(-1,0,all from tl_SoI1, 100, all from tl_SoI3,all from tl_SoI3,all from tl_SoI3); //repetition
+ var RoSoI vl_goodValues := {
+ {},
+ {-1},{0},{1},{2},{6},{7},{8},{9},{100},
+ {-1,0},{-1,1},{-1,2},{-1,6},{-1,7},{-1,8},{-1,9},{-1,100},
+ {0,2},{0,6},{0,7},{0,8},{0,9},{0,100},
+ {1,2},{1,6},{1,7},{1,8},{1,9},{1,100},
+ {2,6},{2,7},{2,8},{2,9},{2,100},
+ {6,100},{7,100},{8,100},{9,100},
+ {-1,0,1},{-1,0,2},{-1,0,6},{-1,0,7},{-1,0,8},{-1,0,9},{-1,0,100},
+ {-1,2,6},{-1,2,7},{-1,2,8},{-1,2,9},{-1,2,100},
+ {-1,6,100},{-1,7,100},{-1,8,100},{-1,9,100},
+ {1,2,6},{1,2,7},{1,2,8},{1,2,9},{1,2,100},
+ {0,1,2},{0,1,6}, {0,1,7},{0,1,8},{0,1,9},{0,1,100},
+ {0,2,6},{0,2,7},{0,2,8},{0,2,9},{0,2,100},
+ {2,6,100},{2,7,100},{2,8,100},{2,9,100},
+ {1,6,100},{1,7,100},{1,8,100},{1,9,100},
+ {1,2,6,100},
+ {20},{21},{22},
+ {20,-1},{20,0},{20,1},{20,2},{20,6},{20,7},{20,8},{20,9},{20,100},
+ {21,-1},{21,0},{21,1},{21,2},{21,6},{21,7},{21,8},{21,9},{21,100},
+ {22,-1},{22,0},{22,1},{22,2},{22,6},{22,7},{22,8},{22,9},{22,100},
+ {20,21,22},{20,21,-1},{20,21,0},{20,21,1},{20,21,2},{20,21,6},{20,21,7},{20,21,8},{20,21,9},{20,21,100},
+ {20,22,0},{20,22,1},{20,22,2},
+ {20,0,2},{20,0,6},{20,0,7},{20,0,8},{20,0,9},{20,0,100},
+ {20,1,2},{20,1,6},{20,1,7},{20,1,8},{20,1,9},{20,1,100},
+ {20,2,6},{20,2,7},{20,2,8},{20,2,9},{20,2,100},
+ {20,6,100},{20,7,100},{20,8,100},{20,9,100},
+ {21,0,2},{21,0,6},{21,0,7},{21,0,8},{21,0,9},{21,0,100},
+ {21,1,2},{21,1,6},{21,1,7},{21,1,8},{21,1,9},{21,1,100},
+ {21,2,6},{21,2,7},{21,2,8},{21,2,9},{21,2,100},
+ {21,6,100},{21,7,100},{21,8,100},{21,9,100},
+ {22,0,2},{22,0,6},{22,0,7},{22,0,8},{22,0,9},{22,0,100},
+ {22,1,2},{22,1,6},{22,1,7},{22,1,8},{22,1,9},{22,1,100},
+ {22,2,6},{22,2,7},{22,2,8},{22,2,9},{22,2,100},
+ {22,6,100},{22,7,100},{22,8,100},{22,9,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100},{-1,0,1,2,7,20,21,22,20,21,22,100},{-1,0,1,2,8,20,21,22,20,21,22,100},{-1,0,1,2,9,20,21,22,20,21,22,100},
+ {-1,0,1,2,6,20,21,22,20,21,22,100,20,22,21},
+ {-1,0,1,2,7,20,21,22,20,21,22,100,20,22,21},{-1,0,1,2,8,20,21,22,20,21,22,100,20,22,21}
+ };
+ var RoSoI vl_badValues := {{1000},{1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{1,1},{-1,0,1,2,6,7,100},
+ {-1,0,1,2,6,7,8,9,20,21,22,20,21,22,100,20,1,22,20},{1,2,200,1}};
+ f_checkSoITemplate(tl_i6s,vl_goodValues,vl_badValues);
+ }
+
+
+ //=== i7 =====
+ //subset (1,2,(6..9)) length (2)
+
+ testcase tc_subset_soi7ss_eq_dyn() runs on A {
+ var template SoI tl_i7s := subset(all from t_SoI1) length (2);
+ f_checkSoITemplateEquivalence(tl_i7s,t_soi7s_eq);
+ }
+
+ testcase tc_subset_soi7ss_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i7s := subset(all from tl_SoI1) length (2);
+ f_checkSoITemplateEquivalence(tl_i7s,t_soi7s_eq);
+ }
+
+ //subset (1,2,(6..9)) length (2)
+ testcase tc_subset_soi7s_dyn() runs on A {
+ var template SoI tl_i7s := subset(all from t_SoI1) length (2);
+ var RoSoI vl_goodValues := {
+ {1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},
+ {1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i7s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi7s_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i7s := subset(all from tl_SoI1) length (2);
+ var RoSoI vl_goodValues := {
+ {1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},
+ {1,19},{6,7},{6,8},{6,9},{1,6,7,100},{1,2,200}, {1,1},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i7s,vl_goodValues,vl_badValues);
+ }
+ //=== i8 ===
+
+ testcase tc_subset_soi8ss_eq_dyn() runs on A {
+ var template SoI tl_i8s := subset(all from t_SoI1, complement(8,9)) length (2);
+ f_checkSoITemplateEquivalence(tl_i8s,t_soi8s_eq);
+ }
+
+ testcase tc_subset_soi8ss_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i8s := subset(all from tl_SoI1, complement(8,9)) length (2);
+ f_checkSoITemplateEquivalence(tl_i8s,t_soi8s_eq);
+ }
+
+ testcase tc_subset_soi8s_dyn() runs on A {
+ var template SoI tl_i8s := subset(all from t_SoI1, complement(8,9)) length (2);
+ var RoSoI vl_goodValues := {
+ {1,1},{1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9},
+ {1,-1},{1,0},{1,1},{1,3},{1,4},{1,5},{1,10},{1,11},{1,100},
+ {2,-2},{2,-1},{2,0},{2,1},{2,2},{2,3},{2,4},{2,5},{2,10},{6,7},{6,10},
+ {7,7},{7,10},{7,11},
+ {8,6},{8,7},{8,10},{8,11},
+ {9,6},{9,7},{9,11}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i8s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi8s_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i8s := subset(all from tl_SoI1, complement(8,9)) length (2);
+ var RoSoI vl_goodValues := {
+ {1,1},{1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9},
+ {1,-1},{1,0},{1,1},{1,3},{1,4},{1,5},{1,10},{1,11},{1,100},
+ {2,-2},{2,-1},{2,0},{2,1},{2,2},{2,3},{2,4},{2,5},{2,10},{6,7},{6,10},
+ {7,7},{7,10},{7,11},
+ {8,6},{8,7},{8,10},{8,11},
+ {9,6},{9,7},{9,11}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(tl_i8s,vl_goodValues,vl_badValues);
+ }
+
+ //===i9===
+
+ testcase tc_subset_soi9ss_eq_dyn() runs on A {
+ var template SoI tl_i9s := subset(complement(all from t_SoI1)) ;
+ f_checkSoITemplateEquivalence(tl_i9s,t_soi9s_eq);
+ }
+
+ testcase tc_subset_soi9ss_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i9s := subset(complement(all from tl_SoI1)) ;
+ f_checkSoITemplateEquivalence(tl_i9s,t_soi9s_eq);
+ }
+
+
+ //subset(complement(1,2,(6..9))) == (-1, 0,3,4,5,10,11 )
+ testcase tc_subset_soi9s_dyn() runs on A {
+ var template SoI tl_i9s := subset(complement(all from t_SoI1)) ;
+ var RoSoI vl_goodValues := { {}, {-2},{-1},{0},{3},{4},{5},{10},{11},{1000}};
+ var RoSoI vl_badValues := {
+ {1,-3},{1,-2},{1,-1},{1,0},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}, //...
+ {2,-3},{2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}, //...
+ {1},{2},{6},{7},{8},{9},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100},
+ {1,6,7,8,9}, {1,2,6,7,8,9},{-1,-2},{-1,-2,0},{-1,0,3,4,5,10,11}
+ };
+ f_checkSoITemplate(tl_i9s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi9s_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i9s := subset(complement(all from tl_SoI1)) ;
+ var RoSoI vl_goodValues := { {}, {-2},{-1},{0},{3},{4},{5},{10},{11},{1000}};
+ var RoSoI vl_badValues := {
+ {1,-3},{1,-2},{1,-1},{1,0},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}, //...
+ {2,-3},{2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}, //...
+ {1},{2},{6},{7},{8},{9},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100},
+ {1,6,7,8,9}, {1,2,6,7,8,9},{-1,-2},{-1,-2,0},{-1,0,3,4,5,10,11}
+ };
+ f_checkSoITemplate(tl_i9s,vl_goodValues,vl_badValues);
+ }
+
+ //===i10===
+
+ testcase tc_subset_soi10ss_eq_dyn() runs on A {
+ var template SoI tl_i10s := subset(all from t_SoI1, complement(all from t_SoI1)) length (2);
+ f_checkSoITemplateEquivalence(tl_i10s,t_soi10s_eq);
+ }
+
+ testcase tc_subset_soi10ss_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i10s := subset(all from tl_SoI1, complement(all from tl_SoI1)) length (2);
+ f_checkSoITemplateEquivalence(tl_i10s,t_soi10s_eq);
+ }
+
+
+ //t_soi10s=subset(1, 2, (6..9),complement(1, 2, (6..9)))
+ testcase tc_subset_soi10s_dyn() runs on A {
+ var template SoI tl_i10s := subset(all from t_SoI1, complement(all from t_SoI1)) length (2);
+ var RoSoI vl_goodValues := {
+ {1,-3},{1,-2},{1,-1},{1,0},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}, //...
+ {2,-3},{2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}, //...
+ {6,-3},{6,-2},{6,-1},{6,0},{6,3},{6,4}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{3},{4},{6},{7},{8},{9},{1000},{1,1},{2,2},{6,6},{6,9},{9,6},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi10s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi10s_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i10s := subset(all from tl_SoI1, complement(all from tl_SoI1)) length (2);
+ var RoSoI vl_goodValues := {
+ {1,-3},{1,-2},{1,-1},{1,0},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},{1,9},{1,10},{1,11}, //...
+ {2,-3},{2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},{2,9},{2,10},{2,11}, //...
+ {6,-3},{6,-2},{6,-1},{6,0},{6,3},{6,4}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{3},{4},{6},{7},{8},{9},{1000},{1,1},{2,2},{6,6},{6,9},{9,6},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi10s,vl_goodValues,vl_badValues);
+ }
+ //===i11===
+ testcase tc_subset_soi11ss_eq_dyn() runs on A {
+ template SoI tl_i11s := subset(all from t_SoI1, complement(all from t_SoI5)) length (2);
+ f_checkSoITemplateEquivalence(tl_i11s,t_soi11s_eq);
+ }
+
+ testcase tc_subset_soi11ss_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI5 := {1,2};
+ template SoI tl_i11s := subset(all from tl_SoI1, complement(all from tl_SoI5)) length (2);
+ f_checkSoITemplateEquivalence(tl_i11s,t_soi11s_eq);
+ }
+
+ //t_soi11s=subset( 1,2,(6..9),complement(1,2))
+ testcase tc_subset_soi11s_dyn() runs on A {
+ template SoI tl_i11s := subset(all from t_SoI1, complement(all from t_SoI5)) length (2);
+ var RoSoI vl_goodValues := {
+ {1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9},
+ {1,-1},{1,0},{1,3},{1,4},{1,5},{1,10},{1,11},{1,100},
+ {2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,10},{6,7},{6,10},
+ {7,7},{7,10},{7,11},
+ {8,6},{8,7},{8,10},{8,11},{6,6},
+ {9,6},{9,7},{9,11}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},{1,1},{2,2},{6,6,7},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi11s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi11s_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI5 := {1,2};
+ template SoI tl_i11s := subset(all from tl_SoI1, complement(all from tl_SoI5)) length (2);
+ var RoSoI vl_goodValues := {
+ {1,2},{1,6},{1,7},{1,8},{1,9},
+ {2,6},{2,7},{2,8},{2,9},
+ {1,-1},{1,0},{1,3},{1,4},{1,5},{1,10},{1,11},{1,100},
+ {2,-2},{2,-1},{2,0},{2,1},{2,3},{2,4},{2,5},{2,10},{6,7},{6,10},
+ {7,7},{7,10},{7,11},
+ {8,6},{8,7},{8,10},{8,11},{6,6},
+ {9,6},{9,7},{9,11}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1000},{1,1},{2,2},{6,6,7},
+ {1,6,7,100},{1,2,200},{-1,0,1,2,6,7,100}};
+ f_checkSoITemplate(t_soi11s,vl_goodValues,vl_badValues);
+ }
+
+ //=== i12 ===
+ //subset(1, 2, ?);
+ testcase tc_subset_soi12ss_eq_dyn() runs on A {
+ var template SoI tl_i12s := subset(all from t_SoI4);
+ f_checkSoITemplateEquivalence(tl_i12s,t_soi12s_eq);
+ }
+
+ testcase tc_subset_soi12ss_eq_2dyn() runs on A {
+ var template SoI tl_SoI4 := {1,2,?};
+ var template SoI tl_i12s := subset(all from tl_SoI4);
+ f_checkSoITemplateEquivalence(tl_i12s,t_soi12s_eq);
+ }
+
+ testcase tc_subset_soi12s_dyn() runs on A {
+ var template SoI tl_i12s := subset(all from t_SoI4);
+ var RoSoI vl_goodValues := {
+ {},{1},{2},{3},{4},{5},{6},
+ {1,1},{1,2},{1,3},{1,4},{1,6},
+ {2,3},{2,4},{2,5},{2,6},{2,7},
+ {1,2,3},{1,2,4},{1,2,5},{3,2,1},{3,1,2}
+ }
+ var RoSoI vl_badValues := {
+ {1,1,1}, {1,3,4},{1,3,5},{1,3,6},{1,2,3,4}
+ };
+ f_checkSoITemplate(tl_i12s,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_subset_soi12s_2dyn() runs on A {
+ var template SoI tl_SoI4 := {1,2,?};
+ var template SoI tl_i12s := subset(all from tl_SoI4);
+ var RoSoI vl_goodValues := {
+ {},{1},{2},{3},{4},{5},{6},
+ {1,1},{1,2},{1,3},{1,4},{1,6},
+ {2,3},{2,4},{2,5},{2,6},{2,7},
+ {1,2,3},{1,2,4},{1,2,5},{3,2,1},{3,1,2}
+ }
+ var RoSoI vl_badValues := {
+ {1,1,1}, {1,3,4},{1,3,5},{1,3,6},{1,2,3,4}
+ };
+ f_checkSoITemplate(t_soi12s,vl_goodValues,vl_badValues);
+ }
+}//Attila_group
+
+control{
+ execute(tc_subset());
+execute(tc_subset_soi0_eq());
+execute(tc_subset_importing_i0_eq());
+execute(tc_subset_i0());
+execute(tc_subset_importing_i0());
+execute(tc_subset_soi0_1_eq());
+execute(tc_subset_importing_i0_1_eq());
+execute(tc_subset_soi0_1());
+execute(tc_subset_soi1_eq());
+execute(tc_subset_importing_i1_eq());
+execute(tc_subset_i1());
+execute(tc_subset_importing_i1());
+execute(tc_subset_soi2_eq());
+execute(tc_subset_importing_i2_eq());
+execute(tc_subset_i2());
+execute(tc_subset_soi3_eq());
+execute(tc_subset_i3());
+execute(tc_subset_soi4_eq());
+execute(tc_subset_i4());
+execute(tc_subset_soi5_eq());
+execute(tc_subset_i5());
+execute(tc_subset_soi6_eq());
+execute(tc_subset_i6());
+execute(tc_subset_soi7_eq());
+execute(tc_subset_i7());
+execute(tc_subset_soi8_eq());
+execute(tc_subset_i8());
+execute(tc_subset_soi9_eq());
+execute(tc_subset_i9());
+execute(tc_subset_soi10_eq());
+execute(tc_subset_i10());
+execute(tc_subset_soi11_eq());
+execute(tc_subset_i11());
+execute(tc_subset_soi12_eq());
+execute(tc_subset_i12());
+execute(tc_subset_soi13roi_eq());
+execute(tc_subset_soi13roi());
+execute(tc_subset_soi13roi_c_eq());
+execute(tc_subset_soi13roi_c());
+execute(tc_subset_soi0_eq_dyn());
+execute(tc_subset_soi0_eq_2dyn());
+execute(tc_subset_soi0_dyn());
+execute(tc_subset_soi0_2dyn());
+execute(tc_subset_soi1_eq_dyn());
+execute(tc_subset_soi1_eq_2dyn());
+execute(tc_subset_soi1_dyn());
+execute(tc_subset_soi1_2dyn());
+execute(tc_subset_soi2_eq_dyn());
+execute(tc_subset_soi2_eq_2dyn());
+execute(tc_subset_soi2_dyn());
+execute(tc_subset_soi2_2dyn());
+execute(tc_subset_soi3_eq_dyn());
+execute(tc_subset_soi3_eq_2dyn());
+execute(tc_subset_soi3_dyn());
+execute(tc_subset_soi3_2dyn());
+execute(tc_subset_soi4_eq_dyn());
+execute(tc_subset_soi4_eq_2dyn());
+execute(tc_subset_soi4_dyn());
+execute(tc_subset_soi4_2dyn());
+execute(tc_subset_soi5_eq_dyn());
+execute(tc_subset_soi5_eq_2dyn());
+execute(tc_subset_soi5_dyn());
+execute(tc_subset_soi5_2dyn());
+execute(tc_subset_soi6_eq_dyn());
+execute(tc_subset_soi6_eq_2dyn());
+execute(tc_subset_soi6_dyn());
+execute(tc_subset_soi7_eq_dyn());
+execute(tc_subset_soi7_eq_2dyn());
+execute(tc_subset_soi7_dyn());
+execute(tc_subset_soi7_2dyn());
+execute(tc_subset_soi8_eq_dyn());
+execute(tc_subset_soi8_eq_2dyn());
+execute(tc_subset_soi8_dyn());
+execute(tc_subset_soi8_2dyn());
+execute(tc_subset_soi9_eq_dyn());
+execute(tc_subset_soi9_eq_2dyn());
+execute(tc_subset_soi9_dyn());
+execute(tc_subset_soi9_2dyn());
+execute(tc_subset_soi10_eq_dyn());
+execute(tc_subset_soi10_eq_2dyn());
+execute(tc_subset_soi10_dyn());
+execute(tc_subset_soi10_2dyn());
+execute(tc_subset_soi11_eq_dyn());
+execute(tc_subset_soi11_eq_2dyn());
+execute(tc_subset_soi11_dyn());
+execute(tc_subset_soi11_2dyn());
+execute(tc_subset_soi12_eq_dyn());
+execute(tc_subset_soi12_eq_2dyn());
+execute(tc_subset_soi12_dyn());
+execute(tc_subset_soi12_2dyn());
+execute(tc_subset_soi0s_eq());
+execute(tc_subset_soi0s());
+execute(tc_subset_soi0s_1_eq());
+execute(tc_subset_soi0s_1());
+execute(tc_subset_soi1ss_eq());
+execute(tc_subset_soi1s());
+execute(tc_subset_soi2s_eq());
+execute(tc_subset_soi2s());
+execute(tc_subset_soi3s_eq());
+execute(tc_subset_soi3s());
+execute(tc_subset_soi4ss_eq());
+execute(tc_subset_soi4s());
+execute(tc_subset_soi5ss_eq());
+execute(tc_subset_soi5s());
+execute(tc_subset_soi6ss_eq());
+execute(tc_subset_soi6s());
+execute(tc_subset_soi7ss_eq());
+execute(tc_subset_soi7s());
+execute(tc_subset_soi8ss_eq());
+execute(tc_subset_soi8s());
+execute(tc_subset_soi9ss_eq());
+execute(tc_subset_soi9s());
+execute(tc_subset_soi10ss_eq());
+execute(tc_subset_soi10s());
+execute(tc_subset_soi11s_eq());
+execute(tc_subset_soi11s());
+execute(tc_subset_soi12s_eq());
+execute(tc_subset_soi12s());
+execute(tc_subset_soi0s_eq_dyn());
+execute(tc_subset_soi0s_eq_2dyn());
+execute(tc_subset_soi0s_dyn());
+execute(tc_subset_soi0s_2dyn());
+execute(tc_subset_soi1s_eq_dyn());
+execute(tc_subset_soi1s_eq_2dyn());
+execute(tc_subset_soi1s_dyn());
+execute(tc_subset_soi1s_2dyn());
+execute(tc_subset_soi2s_eq_dyn());
+execute(tc_subset_soi2s_eq_2dyn());
+execute(tc_subset_soi2s_dyn());
+execute(tc_subset_soi2s_2dyn());
+execute(tc_subset_soi3ss_eq_dyn());
+execute(tc_subset_soi3ss_eq_2dyn());
+execute(tc_subset_soi3s_dyn());
+execute(tc_subset_soi3s_2dyn());
+execute(tc_subset_soi4ss_eq_dyn());
+execute(tc_subset_soi4ss_eq_2dyn());
+execute(tc_subset_soi4s_dyn());
+execute(tc_subset_soi4s_2dyn());
+execute(tc_subset_soi5ss_eq_dyn());
+execute(tc_subset_soi5ss_eq_2dyn());
+execute(tc_subset_soi5s_dyn());
+execute(tc_subset_soi5s_2dyn());
+execute(tc_subset_soi6ss_eq_dyn());
+execute(tc_subset_soi6ss_eq_2dyn());
+execute(tc_subset_soi6s_dyn());
+execute(tc_subset_soi7ss_eq_dyn());
+execute(tc_subset_soi7ss_eq_2dyn());
+execute(tc_subset_soi7s_dyn());
+execute(tc_subset_soi7s_2dyn());
+execute(tc_subset_soi8ss_eq_dyn());
+execute(tc_subset_soi8ss_eq_2dyn());
+execute(tc_subset_soi8s_dyn());
+execute(tc_subset_soi8s_2dyn());
+execute(tc_subset_soi9ss_eq_dyn());
+execute(tc_subset_soi9ss_eq_2dyn());
+execute(tc_subset_soi9s_dyn());
+execute(tc_subset_soi9s_2dyn());
+execute(tc_subset_soi10ss_eq_dyn());
+execute(tc_subset_soi10ss_eq_2dyn());
+execute(tc_subset_soi10s_dyn());
+execute(tc_subset_soi10s_2dyn());
+execute(tc_subset_soi11ss_eq_dyn());
+execute(tc_subset_soi11ss_eq_2dyn());
+execute(tc_subset_soi11s_dyn());
+execute(tc_subset_soi11s_2dyn());
+execute(tc_subset_soi12ss_eq_dyn());
+execute(tc_subset_soi12ss_eq_2dyn());
+execute(tc_subset_soi12s_dyn());
+execute(tc_subset_soi12s_2dyn());
+
+}
+} with {extension "version R1A01";} // end of module
diff --git a/Regression_Test_java/src/all_from/all_from_subtype.ttcn b/Regression_Test_java/src/all_from/all_from_subtype.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..f1c2ffb69418b1f4ae77add14a1131f680e83906
--- /dev/null
+++ b/Regression_Test_java/src/all_from/all_from_subtype.ttcn
@@ -0,0 +1,196 @@
+/******************************************************************************
+ * 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
+ *
+ ******************************************************************************/
+
+// subtyping and the 'all from' clause
+module all_from_subtype {
+
+import from types all;
+
+
+/* * * * integer * * * */
+template RoI t_RoI1 := { 1, 2, (6..9) };
+template RoI t_RoI2 := { 1, ?, 3 };
+const RoI c_RoI := { 20, 21, 22 };
+
+template PosInt t_posint1 := (0, all from t_RoI1);
+template PosInt t_posint1_exp := (0, 1, 2, (6..9));
+
+template PosInt t_posint2 := (all from c_RoI, 50, 100);
+template PosInt t_posint2_exp := (20, 21, 22, 50, 100);
+
+template PosInt t_posint3 := (10, all from c_RoI, 30, all from t_RoI1);
+template PosInt t_posint3_exp := (10, 20, 21, 22, 30, 1, 2, (6..9));
+
+template ShortRoI t_sroi1 := { 0, (all from t_RoI1, 10), 20 };
+template ShortRoI t_sroi1_exp := { 0, (1, 2, (6..9), 10), 20 };
+
+template ShortRoI t_sroi2 := ( { 1, 2, 3 }, { permutation (all from t_RoI2) } );
+template ShortRoI t_sroi2_exp := ( { 1, 2, 3 }, { permutation (1, ?, 3) } );
+
+testcase tc_all_from_subtype_integer() runs on A
+{
+ if (log2str(t_posint1) != log2str(t_posint1_exp)) {
+ setverdict(fail, "Expected: ", t_posint1_exp, ", got: ", t_posint1);
+ }
+ if (log2str(t_posint2) != log2str(t_posint2_exp)) {
+ setverdict(fail, "Expected: ", t_posint2_exp, ", got: ", t_posint2);
+ }
+ if (log2str(t_posint3) != log2str(t_posint3_exp)) {
+ setverdict(fail, "Expected: ", t_posint3_exp, ", got: ", t_posint3);
+ }
+ if (log2str(t_sroi1) != log2str(t_sroi1_exp)) {
+ setverdict(fail, "Expected: ", t_sroi1_exp, ", got: ", t_sroi1);
+ }
+ if (log2str(t_sroi2) != log2str(t_sroi2_exp)) {
+ setverdict(fail, "Expected: ", t_sroi2_exp, ", got: ", t_sroi2);
+ }
+ setverdict(pass);
+}
+
+/* * * * float * * * */
+template RoF t_RoF := { (-10.0..-2.5), -1.0, 0.0 };
+const RoF c_RoF := { -0.3, -0.2, -0.1 };
+
+template NegFloat t_negfloat := (all from t_RoF, -2.0, all from c_RoF, -100.0);
+template NegFloat t_negfloat_exp := ((-10.0..-2.5), -1.0, 0.0, -2.0, -0.3, -0.2, -0.1, -100.0);
+
+template ShortRoF t_srof := { permutation (all from c_RoF) };
+template ShortRoF t_srof_exp := { permutation (-0.3, -0.2, -0.1) };
+
+testcase tc_all_from_subtype_float() runs on A
+{
+ if (log2str(t_negfloat) != log2str(t_negfloat_exp)) {
+ setverdict(fail, "Expected: ", t_negfloat_exp, ", got: ", t_negfloat);
+ }
+ if (log2str(t_srof) != log2str(t_srof_exp)) {
+ setverdict(fail, "Expected: ", t_srof_exp, ", got: ", t_srof);
+ }
+ setverdict(pass);
+}
+
+/* * * * bitstring * * * */
+template RoBS t_RoBS := { '1010'B, ? };
+const RoBS c_RoBS := { '11011000'B, '00110011'B, '10101010'B };
+
+template ByteString t_bytestr := ('00000000'B, all from c_RoBS, '11111111'B);
+template ByteString t_bytestr_exp := ('00000000'B, '11011000'B, '00110011'B, '10101010'B, '11111111'B);
+
+template ShortRoBS t_srobs := { '1'B, permutation (all from t_RoBS) };
+template ShortRoBS t_srobs_exp := { '1'B, permutation ('1010'B, ?) };
+
+testcase tc_all_from_subtype_bitstring() runs on A
+{
+ if (log2str(t_bytestr) != log2str(t_bytestr_exp)) {
+ setverdict(fail, "Expected: ", t_bytestr_exp, ", got: ", t_bytestr);
+ }
+ if (log2str(t_srobs) != log2str(t_srobs_exp)) {
+ setverdict(fail, "Expected: ", t_srobs_exp, ", got: ", t_srobs);
+ }
+ setverdict(pass);
+}
+
+/* * * * hexstring * * * */
+template RoHS t_RoHS := { '100'H, 'ABC'H };
+const RoHS c_RoHS := { '19A6'H, '999D'H, '1337'H };
+
+template WordString t_wordstr := ('A000'H, 'FFFF'H, all from c_RoHS, '0000'H);
+template WordString t_wordstr_exp := ('A000'H, 'FFFF'H, '19A6'H, '999D'H, '1337'H, '0000'H);
+
+template ShortRoHS t_srohs := { permutation (all from t_RoHS, '180DD'H) };
+template ShortRoHS t_srohs_exp := { permutation ('100'H, 'ABC'H, '180DD'H) };
+
+testcase tc_all_from_subtype_hexstring() runs on A
+{
+ if (log2str(t_wordstr) != log2str(t_wordstr_exp)) {
+ setverdict(fail, "Expected: ", t_wordstr_exp, ", got: ", t_wordstr);
+ }
+ if (log2str(t_srohs) != log2str(t_srohs_exp)) {
+ setverdict(fail, "Expected: ", t_srohs_exp, ", got: ", t_srohs);
+ }
+ setverdict(pass);
+}
+
+/* * * * octetstring * * * */
+template RoOS t_RoOS := { '00'O, 'FF'O };
+const RoOS c_RoOS := { 'E77FB41C'O, 'DEADBEEF'O, 'CDCDCDCD'O };
+
+template DWordString t_dwordstr := (all from c_RoOS, '0FFFFFFF'O);
+template DWordString t_dwordstr_exp := ('E77FB41C'O, 'DEADBEEF'O, 'CDCDCDCD'O, '0FFFFFFF'O);
+
+template ShortRoOS t_sroos := { permutation (?, all from t_RoOS) };
+template ShortRoOS t_sroos_exp := { permutation (?, '00'O, 'FF'O) };
+
+testcase tc_all_from_subtype_octetstring() runs on A
+{
+ if (log2str(t_dwordstr) != log2str(t_dwordstr_exp)) {
+ setverdict(fail, "Expected: ", t_dwordstr_exp, ", got: ", t_dwordstr);
+ }
+ if (log2str(t_sroos) != log2str(t_sroos_exp)) {
+ setverdict(fail, "Expected: ", t_sroos_exp, ", got: ", t_sroos);
+ }
+ setverdict(pass);
+}
+
+/* * * * charstring * * * */
+template RoCS t_RoCS := { ("a".."z"), ("0".."9"), ("A".."Z") };
+const RoCS c_RoCS := { "all_from.ttcn", "types.ttcn", "functions.ttcn", "sapc.ttcn" };
+
+template TtcnFileName t_ttcnfiles := (all from c_RoCS);
+template TtcnFileName t_ttcnfiles_exp := ("all_from.ttcn", "types.ttcn", "functions.ttcn", "sapc.ttcn");
+
+template ShortRoCS t_srocs := { permutation (all from t_RoCS) };
+template ShortRoCS t_srocs_exp := { permutation (("a".."z"), ("0".."9"), ("A".."Z")) };
+
+testcase tc_all_from_subtype_charstring() runs on A
+{
+ if (log2str(t_ttcnfiles) != log2str(t_ttcnfiles_exp)) {
+ setverdict(fail, "Expected: ", t_ttcnfiles_exp, ", got: ", t_ttcnfiles);
+ }
+ if (log2str(t_srocs) != log2str(t_srocs_exp)) {
+ setverdict(fail, "Expected: ", t_srocs_exp, ", got: ", t_srocs);
+ }
+ setverdict(pass);
+}
+
+/* * * * universal charstring * * * */
+template RoUCS t_RoUCS := { "abc", ?, "cba" };
+const RoUCS c_RoUCS := { "nothing", "special", "here" };
+
+template XsdString t_xsdstr := (pattern "<*>", all from c_RoUCS);
+template XsdString t_xsdstr_exp := (pattern "<*>", "nothing", "special", "here");
+
+template ShortRoUCS t_sroucs := { all from t_RoUCS };
+template ShortRoUCS t_sroucs_exp := { "abc", ?, "cba" };
+
+testcase tc_all_from_subtype_universal_charstring() runs on A
+{
+ if (log2str(t_xsdstr) != log2str(t_xsdstr_exp)) {
+ setverdict(fail, "Expected: ", t_xsdstr_exp, ", got: ", t_xsdstr);
+ }
+ if (log2str(t_sroucs) != log2str(t_sroucs_exp)) {
+ setverdict(fail, "Expected: ", t_sroucs_exp, ", got: ", t_sroucs);
+ }
+ setverdict(pass);
+}
+
+control {
+ execute(tc_all_from_subtype_integer());
+ execute(tc_all_from_subtype_float());
+ execute(tc_all_from_subtype_bitstring());
+ execute(tc_all_from_subtype_hexstring());
+ execute(tc_all_from_subtype_octetstring());
+ execute(tc_all_from_subtype_charstring());
+ execute(tc_all_from_subtype_universal_charstring());
+}
+
+}
diff --git a/Regression_Test_java/src/all_from/all_from_superset.ttcn b/Regression_Test_java/src/all_from/all_from_superset.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..069918aebb9ad870338eba3f664feeccd1fa6506
--- /dev/null
+++ b/Regression_Test_java/src/all_from/all_from_superset.ttcn
@@ -0,0 +1,1104 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module all_from_superset
+{
+import from types all;
+import from functions all;
+
+template RoI t_imported_RoI1 := {1, 2, (6..9)};
+template RoI t_imported_RoI2 := {1, *, 3};
+template RoI t_imported_RoI3 := {20,21,22};
+template RoI t_imported_RoI4 := {1, ?, 3};
+//for permutation:
+template RoI t_imported_RoI1_P := {1, 2, *};
+template RoI t_imported_RoI3_P := {1, 2, 3};
+template RoI t_imported_RoI7_P := {1, 2, ?};
+
+//===========Set of Integer================================
+template SoI t_imported_SoI1 := {1,2,(6..9)};
+template SoI t_imported_SoI2 := {1, *, 3};
+template SoI t_imported_SoI3 := {20,21,22};
+
+template RoI t_RoI1 := {1, 2, (6..9)};
+template RoI t_RoI2 := {1, *, 3};
+
+group Csaba_group {
+ // B 1.2.6 Superset
+
+ //EXAMPLE 1:
+
+ template MySetOfType MyTemplate1 := superset (1, 2, 3);
+ // matches any sequence of integers which contains at least one occurrences of the numbers
+ // 1, 2 and 3 in any order and position
+
+ template MySetOfType MyTemplate2_AnyValue := superset (1, 2, ?);
+ // matches any sequence of integers which contains at least one occurrences of the numbers
+ // 1, 2 and at least one more valid integer value (i.e. between 0 and 10, inclusively), in any
+ // order and position
+
+ template MySetOfType MyTemplate3 := superset (1, 2, (3, 4));
+ // matches any sequence of integers which contains at least one occurrences of the numbers
+ // 1, 2 and a number with the value 3 or 4, in any order and position
+
+ template MySetOfType MyTemplate4 := superset (1, 2, complement(3, 4));
+ // any sequence of integers matches which contains at least one occurrences of the numbers
+ // 1, 2 and a valid integer value which is not 3 or 4, in any order and position
+
+ template MySetOfType MyTemplate6 := superset (1, 2, 3) length (7);
+ // matches any sequence of 7 integers which contains at least one occurrences of the numbers
+ // 1, 2 and 3 in any order and position
+
+ template MySetOfType MyTemplate7 := superset (1, 2, ?) length (7 .. infinity);
+ // matches any sequence of at least 7 integers which contains at least one occurrences of the
+ // numbers 1, 2 and 3 in any order and position
+
+ template MySetOfType MyTemplate8 := superset (1, 2, 3) length (2 .. 7);
+ // causes an error, the lower bound of the length attribute contradicts to the minimum number
+ // of elements imposed by the superset argument
+
+ //EXAMPLE 2:
+ template RoI t_RoI1s := {1, 2, ?};
+ template SoI t_SoI1s := superset(all from t_RoI1s);
+ // results in superset(1, 2, ?)
+
+ testcase tc_superset() runs on A
+ {
+ action("superset: ", t_SoI1s);
+ var SoI v;
+
+ v := {};
+ if (not match(v, t_SoI1s)) { setverdict(pass); }
+ else { setverdict(fail, v, " should NOT match ", t_SoI1s); }
+
+ v := { 1 };
+ if (not match(v, t_SoI1s)) { setverdict(pass); }
+ else { setverdict(fail, v, " should NOT match ", t_SoI1s); }
+
+ v := { 1, 2 };
+ if (not match(v, t_SoI1s)) { setverdict(pass); }
+ else { setverdict(fail, v, " should NOT match ", t_SoI1s); }
+
+ v := { 1, 2, 3 };
+ if (match(v, t_SoI1s)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_SoI1s); }
+
+ v := { 1, 2, 4, 8, 16, 32 };
+ if (match(v, t_SoI1s)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_SoI1s); }
+
+ v := { 16, 8, 4, 2, 1 };
+ if (match(v, t_SoI1s)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_SoI1s); }
+
+ v := { 1, 2, 1 };
+ if (match(v, t_SoI1s)) { setverdict(pass); }
+ else { setverdict(fail, v, " should match ", t_SoI1s); }
+
+ v := { 10, 2, 3 };
+ if (not match(v, t_SoI1s)) { setverdict(pass); }
+ else { setverdict(fail, v, " should NOT match ", t_SoI1s); }
+ }
+
+}//Csaba_group
+
+group Attila_group {
+
+ //=============== Templates ==========================
+ //set of integers
+ template SoI t_SoI1 := {1, 2, (6..9)};
+ template SoI t_SoI2 := {1, *, 3};
+ template SoI t_SoI3 := {20,21,22};
+ template SoI t_SoI4 := {1,2,?};
+ template SoI t_SoI5 := {1,2};
+
+ //Superset of Integers
+ template SoI t_i0sup := superset (all from t_SoI3 );
+ template SoI t_i0sup_eq := superset (20,21,22);
+ template SoI t_i0sup_1 := superset ((all from t_SoI3 ));//i.e.: superset((20,21,22)); -it worked!
+ template SoI t_i0sup_1_eq := superset ((20,21,22));
+ template SoI t_i1sup := superset (all from t_SoI1, 100);
+ template SoI t_i1sup_eq := superset (1, 2, (6..9), 100);
+ template SoI t_i2sup := superset (-1,0,all from t_SoI1, 100);
+ template SoI t_i2sup_eq := superset (-1,0,1,2,(6..9),100);
+ template SoI t_i3sup := superset(-1,0,all from t_SoI1, all from t_SoI3, 100);
+ template SoI t_i3sup_eq := superset (-1,0,1,2,(6..9),20,21,22, 100);
+
+ template SoI t_i4sup := superset(-1,0,all from t_SoI1, 100, all from t_SoI3);
+ template SoI t_i4sup_eq := superset (-1,0,1,2,(6..9),100,20,21,22);
+
+ template SoI t_i5sup := superset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3 ); //repetition
+ template SoI t_i5sup_eq := superset (-1,0,1,2,(6..9),100,20,21,22,20,21,22);
+
+ template SoI t_i6sup := superset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3,all from t_SoI3); //repetition
+ template SoI t_i6sup_eq := superset (-1,0,1,2,(6..9),100,20,21,22,20,21,22,20,21,22);
+
+ template SoI t_i7sup := superset(all from t_SoI1) length (7);
+ template SoI t_i7sup_eq := superset(1,2,(6..9)) length (7);
+
+ template SoI t_i7sup_1 := superset(all from t_SoI1) length (6);
+ template SoI t_i7sup_1_eq := superset(1,2,(6..9)) length (6);
+
+ template SoI t_i8sup := superset(all from t_SoI1, complement(8,9)) length (4);
+ template SoI t_i8sup_eq := superset(1,2,(6..9),complement(8,9)) length (4);
+
+ template SoI t_i9sup := superset(complement(all from t_SoI1)) //length (4);
+ template SoI t_i9sup_eq := superset(complement(1,2,(6..9))) //length (4);
+
+ template SoI t_i9sup_1 := superset(complement(all from t_SoI1)) length (4);
+ template SoI t_i9sup_1_eq := superset(complement(1,2,(6..9))) length (4);
+
+ template SoI t_i10sup := superset(all from t_SoI1, complement(all from t_SoI1)) length (4);
+ template SoI t_i10sup_eq := superset(1,2,(6..9),complement(1,2,(6..9) )) length (4);
+
+ template SoI t_i11sup := superset(all from t_SoI1, complement(all from t_SoI5)) length (4);
+ template SoI t_i11sup_eq := superset(1,2,(6..9), complement(1,2)) length (4);
+
+ // compile error (correct behaviour):
+ // template SoI t_i7sup_err := superset(all from t_SoI1) length (2);
+ // There are more (at least 3) elements in the template than it is allowed by the length restriction (2)
+ //template SoI t_i9sup_err := superset(complement(all from t_SoI1)) length (2);
+ //There are more (at least 4) elements in the template than it is allowed by the length restriction (2) <== correct 4 for 7
+ // It is ready, see tc_superset_i7
+
+ template SoI t_importing_i0sup := superset (all from t_imported_RoI3 );
+ template SoI t_importing_i0sup_1 := superset ((all from t_imported_RoI3 ));
+ template SoI t_importing_i1sup := superset (all from t_imported_RoI1, 100);
+ template SoI t_importing_i2sup := superset (-1,0,all from t_imported_RoI1,100);
+
+ //================= Testcases for Static Templates ========================
+
+ //=== i0 ===
+ //t_i0s:=superset (20,21,22)
+ testcase tc_superset_i0_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i0sup,t_i0sup_eq);
+ }
+
+ testcase tc_superset_importing_i0_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_importing_i0sup,t_i0sup_eq);
+ }
+ //local template
+ testcase tc_superset_i0_eq_local() runs on A {
+ template SoI tl_i0sup := superset (all from t_SoI3 );
+ f_checkSoITemplateEquivalence(tl_i0sup,t_i0sup_eq);
+ }
+ testcase tc_superset_importing_i0_eq_local() runs on A {
+ template SoI tl_importing_i0sup := superset (all from t_imported_RoI3 );
+ f_checkSoITemplateEquivalence(tl_importing_i0sup,t_i0sup_eq);
+ }
+ testcase tc_superset_i0_eq_2local() runs on A {
+ template SoI tl_SoI3 := {20,21,22};
+ template SoI tl_i0sup := superset (all from tl_SoI3 );
+ f_checkSoITemplateEquivalence(tl_i0sup,t_i0sup_eq);
+ }
+
+ testcase tc_superset_i0() runs on A {
+ var RoSoI vl_goodValues := {{20,21,22},{20,21,22,23}, {24,23,22,21,20,19}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21}};
+ f_checkSoITemplate(t_i0sup,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_superset_importing_i0() runs on A {
+ var RoSoI vl_goodValues := {{20,21,22},{20,21,22,23}, {24,23,22,21,20,19}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21}};
+ f_checkSoITemplate(t_importing_i0sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i0sup_1===
+ //superset ((20,21,22))
+ testcase tc_superset_i0_1_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i0sup_1,t_i0sup_1_eq);
+ }
+
+ testcase tc_superset_i0_1_eq_local() runs on A {
+ template SoI tl_i0sup_1 := superset ((all from t_SoI3 ))
+ f_checkSoITemplateEquivalence(tl_i0sup_1,t_i0sup_1_eq);
+ }
+
+ testcase tc_superset_i0_1_eq_2local() runs on A {
+ template SoI tl_SoI3 := {20,21,22};
+ template SoI tl_i0sup_1 := superset ((all from tl_SoI3 ))
+ f_checkSoITemplateEquivalence(tl_i0sup_1,t_i0sup_1_eq);
+ }
+
+ //superset ((20,21,22));
+ testcase tc_superset_i0_1() runs on A {
+ var RoSoI vl_goodValues := {{20},{21},{22},{20,21},{22,20},{22,21},{20,21,22},{20,21,22,23},{24,23,22,21,20,19}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{}};
+ f_checkSoITemplate(t_i0sup_1,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_superset_i0_1_2local() runs on A {
+ template SoI tl_SoI3 := {20,21,22};
+ template SoI tl_i0sup_1 := superset ((all from tl_SoI3 ))
+ var RoSoI vl_goodValues := {{20},{21},{22},{20,21},{22,20},{22,21},{20,21,22},{20,21,22,23},{24,23,22,21,20,19}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{}};
+ f_checkSoITemplate(tl_i0sup_1,vl_goodValues,vl_badValues);
+ }
+ //=== i1sup ===
+ testcase tc_superset_i1_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i1sup,t_i1sup_eq);
+ }
+
+ testcase tc_superset_i1() runs on A {
+ var RoSoI vl_goodValues := {{1,2,6,100}, {1,2,7,100},{1,2,8,100},{1,2,9,100}, {1,2,3,4,5,6,7,8,9,100}, {1,2,3,4,5,6,7,8,9,100}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100},{2,6,100}, {2,6,7,8,9,100},{1,6,7,8,9,100}};
+ f_checkSoITemplate(t_i1sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i2 ===
+ testcase tc_superset_i2_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i2sup,t_i2sup_eq);
+ }
+
+ testcase tc_superset_i2() runs on A {
+ var RoSoI vl_goodValues := {{-1,0,1,2,6,20,21,22,100},{-1,0,1,2,7,20,21,22,100},{-1,0,1,2,8,20,21,22,100},{-1,0,1,2,9,20,21,22,100},
+ {-1,0,1,2,6,7,8,9,20,21,22,100},{1,-1,2,0,3,4,5,6,7,8,9,20,21,22,100}, {1,2,3,4,5,6,7,8,9,20,21,22,100,-1,0}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100}, {2,6,7,8,9,100},{1,6,7,8,9,100}};
+ f_checkSoITemplate(t_i2sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i3 ===
+ //superset (-1,0,1,2,(6..9),20,21,22, 100);
+ testcase tc_superset_i3_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i3sup,t_i3sup_eq);
+ }
+
+ testcase tc_superset_i3() runs on A {
+ var RoSoI vl_goodValues := {{20,21,22,-1,0,1,2,6,7,8,9,100},{20,21,22,1,-1,2,0,3,4,5,6,20,21,22,7,8,9,100}, {1,20,21,22,2,3,4,5,6,7,8,9,100,-1,0}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100}, {2,6,7,8,9,20,21,22,100},{20,21,22,1,6,7,8,9,100}};
+ f_checkSoITemplate(t_i3sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i4 ===
+ //superset (-1,0,1,2,(6..9),100,20,21,22); //order
+ testcase tc_superset_i4_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i4sup,t_i4sup_eq);
+ }
+
+ testcase tc_superset_i4() runs on A {
+ var RoSoI vl_goodValues := {
+ {20,21,22,-1,0,1,2,6,100},{20,21,22,-1,0,1,2,7,100},{20,21,22,-1,0,1,2,6,100},{20,21,22,-1,0,1,2,8,100},{20,21,22,-1,0,1,2,9,100},
+ {20,21,22,-1,0,1,2,6,7,8,9,100},
+ {20,21,22,1,-1,2,0,3,4,5,6,20,21,22,7,8,9,100},
+ {1,20,21,22,2,3,4,5,6,7,8,9,100,-1,0}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100}, {2,6,7,8,9,20,21,22,100},{20,21,22,1,6,7,8,9,100}};
+ f_checkSoITemplate(t_i4sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i5 ===
+ //superset (-1,0,1,2,(6..9),100,20,21,22,20,21,22);
+ testcase tc_superset_i5_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i5sup,t_i5sup_eq);
+ }
+
+ testcase tc_superset_i5() runs on A {
+ var RoSoI vl_goodValues := {
+ {20,21,22,-1,0,1,2,6,100,20,21,22},{20,21,22,-1,0,1,2,7,100,20,21,22},{20,21,22,-1,0,1,2,8,100,20,21,22},{20,21,22,-1,0,1,2,9,100,20,21,22},
+ {20,21,22,-1,0,1,2,6,7,100,20,21,22},
+ {20,21,22,-1,0,1,2,6,7,8,9,100,20,21,22},
+ {20,21,22,20,21,22,1,-1,2,0,3,4,5,6,20,21,22,7,8,9,100},
+ {20,21,22,1,20,21,22,2,3,4,5,6,7,8,9,100,-1,0}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100}, {2,6,7,8,9,20,21,22,100},{20,21,22,1,6,7,8,9,100}};
+ f_checkSoITemplate(t_i5sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i6 ===
+ //superset (-1,0,1,2,(6..9),100,20,21,22,20,21,22,20,21,22);
+ testcase tc_superset_i6_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i6sup,t_i6sup_eq);
+ }
+
+ testcase tc_superset_i6() runs on A {
+ var RoSoI vl_goodValues :=
+ {
+ {20,21,22,20,21,22,-1,0,1,2,6,100,20,21,22},{20,21,22,20,21,22,-1,0,1,2,7,100,20,21,22},
+ {20,21,22,20,21,22,-1,0,1,2,8,9,100,20,21,22},{20,21,22,20,21,22,-1,0,1,2,6,7,8,100,20,21,22},
+ {20,21,22,20,21,22,-1,0,1,2,6,7,8,9,100,20,21,22},
+ {20,21,22,1,-1,2,0,3,4,5,6,20,21,22,7,20,21,22,8,9,100,20,21,22},
+ {1,20,21,22,2,3,4,5,6,7,8,9,100,-1,0,20,21,22,20,21,22}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100}, {2,6,7,8,9,20,21,22,100},{20,21,22,1,6,7,8,9,100}};
+ f_checkSoITemplate(t_i6sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i7 ===
+ //superset(1,2,(6..9)) length (7);
+ testcase tc_superset_i7_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i7sup,t_i7sup_eq);
+ }
+
+ testcase tc_superset_i7() runs on A {
+ var RoSoI vl_goodValues := {
+ {1,2,6,100,200,300,400},{1,2,7,100,200,300,400},{1,2,8,100,200,300,400},{1,2,9,100,200,300,400},
+ {2,1,6,100,200,300,400},
+ {1,2,6,7,8,9,0},{1,2,6,7,8,9,1000},{1,2,-1,6,7,8,9}};
+ var RoSoI vl_badValues := {{1,2,3,4,5,6,7,8,9},{0},{1},{-1},{1000},{1,19},{},
+ {20},{21},{22},{20,21},
+ {22,20},{22,21,100},
+ {2,6,7,8,9,100},{1,6,7,8,9,100}};
+ f_checkSoITemplate(t_i7sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i7sup_1 ===
+ //superset(1,2,(6..9)) length (6);
+ testcase tc_superset_i7_1_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i7sup_1,t_i7sup_1_eq);
+ }
+ testcase tc_superset_i7_1() runs on A {
+ var RoSoI vl_goodValues := {{1,2,6,7,8,9},
+ {1,2,6,100,200,300},{1,2,7,100,200,300},{1,2,7,100,200,300},{1,2,8,100,200,300},{1,2,9,100,200,300}};
+ var RoSoI vl_badValues := {{1,2,3,4,5,6,7,8,9},
+ {0},{1},{-1},{1000},
+ {1,19},{},{20},{21},{22},{20,21},{22,20},
+ {22,21,100},
+ {2,6,7,8,9,100},{1,6,7,8,9,100}};
+ f_checkSoITemplate(t_i7sup_1,vl_goodValues,vl_badValues);
+ }
+
+ //=== i8 ===
+ //superset(1,2,(6..9),complement(8,9)) length (4);
+ testcase tc_superset_i8_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i8sup,t_i8sup_eq);
+ }
+
+ testcase tc_superset_i8() runs on A {
+ var RoSoI vl_goodValues := {
+ {1,2,6,6},{1,2,7,6},{1,2,8,6},{1,2,9,6},
+ {1,2,6,7},{1,2,7,7},{1,2,8,7},{1,2,9,7},
+ {1,2,6,10},{1,2,7,10},{1,2,8,10},{1,2,9,10},
+ {1,2,8,6},{1,2,8,7}
+ };
+ var RoSoI vl_badValues := {
+ {1,2,8,9},{1,2,9,9},
+ {1,2,8,9},{1,2,9,9},
+ {1,2,6,10,11},{1,2,7,10,12,13},{1,2,5,10},{1,2,4,10},
+
+ {},
+ {0},{1},{2},{1000},
+ {1,2},{1,6},{20,21},{22,20},
+ {22,21,100},{1,2,6},
+ {1,2,3,4,5,6,7,8,9},
+ {2,6,7,8,9,100},{1,6,7,8,9,100},{1,2,3,4,5,6,7,8,9} };
+ f_checkSoITemplate(t_i8sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i9 ===
+ //superset(complement(1,2,(6..9))) //length (4);
+ // It matches all set of integers which contains at least one integer which is not 1,2,6,7,8 or 9
+ testcase tc_superset_i9_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i9sup,t_i9sup_eq);
+ }
+ testcase tc_superset_i9() runs on A {
+ var RoSoI vl_goodValues := {
+ {0,3,4,5},{0,10,11,12},{0},{3},{4},{5},{10},{11},{3,4},{1,2,3},{1,2,6,10},{1,2,6,7,8,9,10}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1,2},{1,6},{1,7},{1,8},{1,9},{2,6},{2,7},{2,8},{2,9},{1,2,6},{1,2,6,9}
+ }
+ f_checkSoITemplate(t_i9sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i9sup_1 ===
+ //superset(complement(1,2,(6..9))) length (4);
+ // It matches all set of integers with length 4 which contains at least one integer which is not 1,2,6,7,8 or 9
+ testcase tc_superset_i9_1_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i9sup_1,t_i9sup_1_eq);
+ }
+ testcase tc_superset_i9_1() runs on A {
+ var RoSoI vl_goodValues := {
+ {0,3,4,5},{0,10,11,12}, //4matches to compl
+ {1,3,4,5},{2,3,4,5},{6,3,4,5}, //3 matches
+ {1,2,10,11}, //2matches to compl value list
+ {1,2,6,10} //1matches
+ };
+ var RoSoI vl_badValues := {{0},{3},{4},{5},{10},{11},{3,4},{1,2,3},
+ {},{1},{2},{6},{7},{8},{9},{1,2},{1,6},{1,7},{1,8},{1,9},{2,6},{2,7},{2,8},{2,9},{1,2,6},{1,2,6,9},{1,2,6,7,8,9,10}
+ }
+ f_checkSoITemplate(t_i9sup_1,vl_goodValues,vl_badValues);
+ }
+ //=== i10 ===
+ //superset(1,2,(6..9),complement(1,2,(6..9) )) length (4);
+ //This matches with set of values (with length of 4) which contains at least once values from the list 1,2,(6..9) furthermore one value which does not matches
+ // with that list
+ testcase tc_superset_i10_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i10sup,t_i10sup_eq);
+ }
+
+ testcase tc_superset_i10() runs on A {
+ var RoSoI vl_goodValues := {
+ {1,2,6,10},{1,2,7,11},{1,2,8,-1},{1,2,9,0},{1,2,9,1000}
+ };
+ var RoSoI vl_badValues := {
+ {0},{3},{4},{5},{10},{11},{3,4},{1,2,3},
+ {},{1},{2},{6},{7},{8},{9},{1,2},{1,6},{1,7},{1,8},{1,9},{2,6},{2,7},{2,8},{2,9},{1,2,6},
+ {1,2,6,9},{0,3,4,5},{0,10,11,12}, //4matches to compl
+ {1,3,4,5},{2,3,4,5},{6,3,4,5}, //3 matches{1,2,6,7,8,9,10}
+ {1,3,4,5},
+ {2,3,4,5},
+ {6,3,4,5},
+ {1,2,10,11}
+ }
+ f_checkSoITemplate(t_i10sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i11 ===
+ // superset(1,2,(6..9), complement(1,2)) length (4);
+
+ testcase tc_superset_i11_eq() runs on A {
+ f_checkSoITemplateEquivalence(t_i11sup,t_i11sup_eq);
+ }
+
+ testcase tc_superset_i11() runs on A {
+ var RoSoI vl_goodValues := {
+ {1,2,6,0},{1,2,7,3},{1,2,8,3},{1,2,9,4},{1,2,9,1000}
+ };
+ var RoSoI vl_badValues := {
+ {0},{3},{4},{5},{10},{11},{3,4},{1,2,3},
+ {},{1},{2},{6},{7},{8},{9},{1,2},{1,6},{1,7},{1,8},{1,9},{2,6},{2,7},{2,8},{2,9},{1,2,6},
+ {1,2,6,1},{0,3,4,5},{0,10,11,12},
+ {1,3,4,5},{2,3,4,5},{6,3,4,5},
+ {1,3,4,5},
+ {2,3,4,5},
+ {6,3,4,5},
+ {1,2,10,11}
+ }
+ f_checkSoITemplate(t_i11sup,vl_goodValues,vl_badValues);
+ }
+ //========== Testcases for Dynamic Templates ==============
+
+ //=== i0 ===
+ testcase tc_superset_i0_eq_dyn() runs on A {
+ var template SoI tl_i0sup := superset (all from t_SoI3 );
+ f_checkSoITemplateEquivalence(tl_i0sup,t_i0sup_eq);
+ }
+ testcase tc_superset_importing_i0_eq_dyn() runs on A {
+ var template SoI tl_importing_i0sup := superset (all from t_imported_RoI3 );
+ f_checkSoITemplateEquivalence(tl_importing_i0sup,t_i0sup_eq);
+ }
+
+ testcase tc_superset_i0_eq_2dyn() runs on A {
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i0sup := superset (all from tl_SoI3 );
+ f_checkSoITemplateEquivalence(tl_i0sup,t_i0sup_eq);
+ }
+
+ testcase tc_superset_i0_dyn() runs on A {
+ var template SoI tl_i0sup := superset (all from t_SoI3 );
+ var RoSoI vl_goodValues := {{20,21,22},{20,21,22,23}, {24,23,22,21,20,19}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21}};
+ f_checkSoITemplate(tl_i0sup,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_superset_i0_2dyn() runs on A {
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i0sup := superset (all from tl_SoI3 );
+ var RoSoI vl_goodValues := {{20,21,22},{20,21,22,23}, {24,23,22,21,20,19}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21}};
+ f_checkSoITemplate(tl_i0sup,vl_goodValues,vl_badValues);
+ }
+ //=== i1 ===
+ //superset (1, 2, (6..9), 100);
+
+ testcase tc_superset_i1_eq_dyn() runs on A {
+ var template SoI tl_i1sup := superset (all from t_SoI1, 100);
+ f_checkSoITemplateEquivalence(tl_i1sup,t_i1sup_eq);
+ }
+
+ testcase tc_superset_importing_i1_eq_dyn() runs on A {
+ var template SoI tl_importing_i1sup := superset (all from t_imported_RoI1, 100);
+ f_checkSoITemplateEquivalence(tl_importing_i1sup,t_i1sup_eq);
+ }
+ testcase tc_superset_i1_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i1sup := superset (all from tl_SoI1, 100);
+ f_checkSoITemplateEquivalence(tl_i1sup,t_i1sup_eq);
+ }
+
+ testcase tc_superset_i1_dyn() runs on A {
+ var template SoI tl_i1sup := superset (all from t_SoI1, 100);
+ var RoSoI vl_goodValues := {{1,2,6,100}, {1,2,7,100},{1,2,8,100},{1,2,9,100}, {1,2,3,4,5,6,7,8,9,100}, {1,2,3,4,5,6,7,8,9,100}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100},{2,6,100}, {2,6,7,8,9,100},{1,6,7,8,9,100}};
+ f_checkSoITemplate(tl_i1sup,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_superset_i1_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i1sup := superset (all from tl_SoI1, 100);
+ var RoSoI vl_goodValues := {{1,2,6,100}, {1,2,7,100},{1,2,8,100},{1,2,9,100}, {1,2,3,4,5,6,7,8,9,100}, {1,2,3,4,5,6,7,8,9,100}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100},{2,6,100}, {2,6,7,8,9,100},{1,6,7,8,9,100}};
+ f_checkSoITemplate(tl_i1sup,vl_goodValues,vl_badValues);
+ }
+ //=== i2 ===
+ testcase tc_superset_i2_eq_dyn() runs on A {
+ var template SoI tl_i2sup := superset (-1,0,all from t_SoI1, 100);
+ f_checkSoITemplateEquivalence(tl_i2sup,t_i2sup_eq);
+ }
+
+ testcase tc_superset_importing_i2_eq_dyn() runs on A {
+ var template SoI tl_importing_i2sup := superset (-1,0,all from t_imported_RoI1,100);
+ f_checkSoITemplateEquivalence(tl_importing_i2sup,t_i2sup_eq);
+ }
+
+ testcase tc_superset_i2_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i2sup := superset (-1,0,all from tl_SoI1, 100);
+ f_checkSoITemplateEquivalence(tl_i2sup,t_i2sup_eq);
+ }
+
+ testcase tc_superset_i2_dyn() runs on A {
+ var template SoI tl_i2sup := superset (-1,0,all from t_SoI1, 100);
+ var RoSoI vl_goodValues := {{-1,0,1,2,6,20,21,22,100},{-1,0,1,2,7,20,21,22,100},{-1,0,1,2,8,20,21,22,100},{-1,0,1,2,9,20,21,22,100},
+ {-1,0,1,2,6,7,8,9,20,21,22,100},{1,-1,2,0,3,4,5,6,7,8,9,20,21,22,100}, {1,2,3,4,5,6,7,8,9,20,21,22,100,-1,0}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100}, {2,6,7,8,9,100},{1,6,7,8,9,100}};
+ f_checkSoITemplate(tl_i2sup,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_superset_i2_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i2sup := superset (-1,0,all from tl_SoI1, 100);
+ var RoSoI vl_goodValues := {{-1,0,1,2,6,20,21,22,100},{-1,0,1,2,7,20,21,22,100},{-1,0,1,2,8,20,21,22,100},{-1,0,1,2,9,20,21,22,100},
+ {-1,0,1,2,6,7,8,9,20,21,22,100},{1,-1,2,0,3,4,5,6,7,8,9,20,21,22,100}, {1,2,3,4,5,6,7,8,9,20,21,22,100,-1,0}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100}, {2,6,7,8,9,100},{1,6,7,8,9,100}};
+ f_checkSoITemplate(tl_i2sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i3 ===
+ //superset (-1,0,1,2,(6..9),20,21,22, 100);
+ testcase tc_superset_i3_eq_dyn() runs on A {
+ var template SoI tl_i3sup := superset(-1,0,all from t_SoI1, all from t_SoI3, 100);
+ f_checkSoITemplateEquivalence(tl_i3sup,t_i3sup_eq);
+ }
+
+ testcase tc_superset_i3_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i3sup := superset(-1,0,all from tl_SoI1, all from tl_SoI3, 100);
+ f_checkSoITemplateEquivalence(tl_i3sup,t_i3sup_eq);
+ }
+
+ testcase tc_superset_i3_dyn() runs on A {
+ var template SoI tl_i3sup := superset(-1,0,all from t_SoI1, all from t_SoI3, 100);
+ var RoSoI vl_goodValues := {{20,21,22,-1,0,1,2,6,7,8,9,100},{20,21,22,1,-1,2,0,3,4,5,6,20,21,22,7,8,9,100}, {1,20,21,22,2,3,4,5,6,7,8,9,100,-1,0}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100}, {2,6,7,8,9,20,21,22,100},{20,21,22,1,6,7,8,9,100}};
+ f_checkSoITemplate(t_i3sup,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_superset_i3_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i3sup := superset(-1,0,all from tl_SoI1, all from tl_SoI3, 100);
+ var RoSoI vl_goodValues := {{20,21,22,-1,0,1,2,6,7,8,9,100},{20,21,22,1,-1,2,0,3,4,5,6,20,21,22,7,8,9,100}, {1,20,21,22,2,3,4,5,6,7,8,9,100,-1,0}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100}, {2,6,7,8,9,20,21,22,100},{20,21,22,1,6,7,8,9,100}};
+ f_checkSoITemplate(t_i3sup,vl_goodValues,vl_badValues);
+ }
+
+
+ //=== i4 ===
+ //superset (-1,0,1,2,(6..9),100,20,21,22);
+
+ testcase tc_superset_i4_eq_dyn() runs on A {
+ var template SoI tl_i4sup := superset(-1,0,all from t_SoI1, 100, all from t_SoI3);
+ f_checkSoITemplateEquivalence(tl_i4sup,t_i4sup_eq);
+ }
+ testcase tc_superset_i4_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i4sup := superset(-1,0,all from tl_SoI1, 100, all from tl_SoI3);
+ f_checkSoITemplateEquivalence(tl_i4sup,t_i4sup_eq);
+ }
+
+ testcase tc_superset_i4_dyn() runs on A {
+ var template SoI tl_i4sup := superset(-1,0,all from t_SoI1, 100, all from t_SoI3);
+ var RoSoI vl_goodValues := {
+ {20,21,22,-1,0,1,2,6,100},{20,21,22,-1,0,1,2,7,100},{20,21,22,-1,0,1,2,6,100},{20,21,22,-1,0,1,2,8,100},{20,21,22,-1,0,1,2,9,100},
+ {20,21,22,-1,0,1,2,6,7,8,9,100},
+ {20,21,22,1,-1,2,0,3,4,5,6,20,21,22,7,8,9,100},
+ {1,20,21,22,2,3,4,5,6,7,8,9,100,-1,0}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100}, {2,6,7,8,9,20,21,22,100},{20,21,22,1,6,7,8,9,100}};
+ f_checkSoITemplate(tl_i4sup,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_superset_i4_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ var template SoI tl_i4sup := superset(-1,0,all from tl_SoI1, 100, all from tl_SoI3);
+ var RoSoI vl_goodValues := {
+ {20,21,22,-1,0,1,2,6,100},{20,21,22,-1,0,1,2,7,100},{20,21,22,-1,0,1,2,6,100},{20,21,22,-1,0,1,2,8,100},{20,21,22,-1,0,1,2,9,100},
+ {20,21,22,-1,0,1,2,6,7,8,9,100},
+ {20,21,22,1,-1,2,0,3,4,5,6,20,21,22,7,8,9,100},
+ {1,20,21,22,2,3,4,5,6,7,8,9,100,-1,0}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},{22,21,100}, {2,6,7,8,9,20,21,22,100},{20,21,22,1,6,7,8,9,100}};
+ f_checkSoITemplate(tl_i4sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i5 ===
+ //superset (-1,0,1,2,(6..9),100,20,21,22,20,21,22);
+
+ testcase tc_superset_i5_eq_dyn() runs on A {
+ template SoI tl_i5sup := superset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3 ); //repetition
+ f_checkSoITemplateEquivalence(tl_i5sup,t_i5sup_eq);
+ }
+
+ testcase tc_superset_i5_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ template SoI tl_i5sup := superset(-1,0,all from tl_SoI1, 100, all from tl_SoI3,all from tl_SoI3 ); //repetition
+ f_checkSoITemplateEquivalence(tl_i5sup,t_i5sup_eq);
+ }
+
+ testcase tc_superset_i5_dyn() runs on A {
+ template SoI tl_i5sup := superset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3 );
+
+ var RoSoI vl_goodValues := {
+ {20,21,22,-1,0,1,2,6,100,20,21,22},
+ {20,21,22,-1,0,1,2,7,100,20,21,22},
+ {20,21,22,-1,0,1,2,8,100,20,21,22},
+ {20,21,22,-1,0,1,2,9,100,20,21,22},
+ {20,21,22,-1,0,1,2,6,7,100,20,21,22},
+ {20,21,22,-1,0,1,2,6,7,8,9,100,20,21,22},
+ {20,21,22,20,21,22,1,-1,2,0,3,4,5,6,20,21,22,7,8,9,100},
+ {20,21,22,1,20,21,22,2,3,4,5,6,7,8,9,100,-1,0}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},
+ {20},{21},{22},{20,21},{22,20},{22,21,100},
+ {2,6,7,8,9,20,21,22,100},{20,21,22,1,6,7,8,9,100}};
+ f_checkSoITemplate(tl_i5sup,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_superset_i5_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_SoI3 := {20,21,22};
+ template SoI tl_i5sup := superset(-1,0,all from tl_SoI1, 100, all from tl_SoI3,all from tl_SoI3 );
+
+ var RoSoI vl_goodValues := {
+ {20,21,22,-1,0,1,2,6,100,20,21,22},
+ {20,21,22,-1,0,1,2,7,100,20,21,22},
+ {20,21,22,-1,0,1,2,8,100,20,21,22},
+ {20,21,22,-1,0,1,2,9,100,20,21,22},
+ {20,21,22,-1,0,1,2,6,7,100,20,21,22},
+ {20,21,22,-1,0,1,2,6,7,8,9,100,20,21,22},
+ {20,21,22,20,21,22,1,-1,2,0,3,4,5,6,20,21,22,7,8,9,100},
+ {20,21,22,1,20,21,22,2,3,4,5,6,7,8,9,100,-1,0}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},
+ {20},{21},{22},{20,21},{22,20},{22,21,100},
+ {2,6,7,8,9,20,21,22,100},{20,21,22,1,6,7,8,9,100}};
+ f_checkSoITemplate(tl_i5sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i6 ===
+ // superset (-1,0,1,2,(6..9),100,20,21,22,20,21,22,20,21,22);
+ testcase tc_superset_i6_eq_dyn() runs on A {
+ var template SoI tl_i6sup := superset(-1,0,all from t_SoI1, 100, all from t_SoI3,all from t_SoI3,all from t_SoI3); //repetition
+ f_checkSoITemplateEquivalence(tl_i6sup,t_i6sup_eq);
+ }
+
+ testcase tc_superset_i6_dyn() runs on A {
+ var RoSoI vl_goodValues :=
+ {
+ {20,21,22,20,21,22,-1,0,1,2,6,100,20,21,22},{20,21,22,20,21,22,-1,0,1,2,7,100,20,21,22},
+ {20,21,22,20,21,22,-1,0,1,2,8,9,100,20,21,22},{20,21,22,20,21,22,-1,0,1,2,6,7,8,100,20,21,22},
+ {20,21,22,20,21,22,-1,0,1,2,6,7,8,9,100,20,21,22},
+ {20,21,22,1,-1,2,0,3,4,5,6,20,21,22,7,20,21,22,8,9,100,20,21,22},
+ {1,20,21,22,2,3,4,5,6,7,8,9,100,-1,0,20,21,22,20,21,22}};
+ var RoSoI vl_badValues := {{0},{1},{-1},{1000},{1,19},{},{20},{21},{22},{20,21},{22,20},
+ {22,21,100},
+ {2,6,7,8,9,20,21,22,100},{20,21,22,1,6,7,8,9,100},{20,21,22,1,6,7,8,9,100}
+ };
+ f_checkSoITemplate(t_i6sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i7 ===
+ //superset(1,2,(6..9)) length (7);
+
+ testcase tc_superset_i7_eq_dyn() runs on A {
+ var template SoI tl_i7sup := superset(all from t_SoI1) length (7);
+ f_checkSoITemplateEquivalence(tl_i7sup,t_i7sup_eq);
+ }
+
+ testcase tc_superset_i7_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i7sup := superset(all from tl_SoI1) length (7);
+ f_checkSoITemplateEquivalence(tl_i7sup,t_i7sup_eq);
+ }
+ testcase tc_superset_i7_dyn() runs on A {
+ var template SoI tl_i7sup := superset(all from t_SoI1) length (7);
+ var RoSoI vl_goodValues := {
+ {1,2,6,100,200,300,400},{1,2,7,100,200,300,400},{1,2,8,100,200,300,400},{1,2,9,100,200,300,400},
+ {2,1,6,100,200,300,400},
+ {1,2,6,7,8,9,0},{1,2,6,7,8,9,1000},{1,2,-1,6,7,8,9}};
+ var RoSoI vl_badValues := {{1,2,3,4,5,6,7,8,9},{0},{1},{-1},{1000},{1,19},{},
+ {20},{21},{22},{20,21},
+ {22,20},{22,21,100},
+ {2,6,7,8,9,100},{1,6,7,8,9,100}};
+ f_checkSoITemplate(tl_i7sup,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_superset_i7_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i7sup := superset(all from tl_SoI1) length (7);
+ var RoSoI vl_goodValues := {
+ {1,2,6,100,200,300,400},{1,2,7,100,200,300,400},{1,2,8,100,200,300,400},{1,2,9,100,200,300,400},
+ {2,1,6,100,200,300,400},
+ {1,2,6,7,8,9,0},{1,2,6,7,8,9,1000},{1,2,-1,6,7,8,9}};
+ var RoSoI vl_badValues := {{1,2,3,4,5,6,7,8,9},{0},{1},{-1},{1000},{1,19},{},
+ {20},{21},{22},{20,21},
+ {22,20},{22,21,100},
+ {2,6,7,8,9,100},{1,6,7,8,9,100}};
+ f_checkSoITemplate(tl_i7sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i7sup_1 ===
+ //superset(1,2,(6..9)) length (6);
+ testcase tc_superset_i7_1_eq_dyn() runs on A {
+ template SoI tl_i7sup_1 := superset(all from t_SoI1) length (6);
+ f_checkSoITemplateEquivalence(tl_i7sup_1,t_i7sup_1_eq);
+ }
+
+ testcase tc_superset_i7_1_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i7sup_1 := superset(all from tl_SoI1) length (6);
+ f_checkSoITemplateEquivalence(tl_i7sup_1,t_i7sup_1_eq);
+ }
+
+ testcase tc_superset_i7_1_dyn() runs on A {
+ template SoI tl_i7sup_1 := superset(all from t_SoI1) length (6);
+ var RoSoI vl_goodValues := {{1,2,6,7,8,9},
+ {1,2,6,100,200,300},{1,2,7,100,200,300},{1,2,7,100,200,300},{1,2,8,100,200,300},{1,2,9,100,200,300}};
+ var RoSoI vl_badValues := {{1,2,3,4,5,6,7,8,9},
+ {0},{1},{-1},{1000},
+ {1,19},{},{20},{21},{22},{20,21},{22,20},
+ {22,21,100},
+ {2,6,7,8,9,100},{1,6,7,8,9,100}};
+ f_checkSoITemplate(tl_i7sup_1,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_superset_i7_1_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i7sup_1 := superset(all from tl_SoI1) length (6);
+ var RoSoI vl_goodValues := {{1,2,6,7,8,9},
+ {1,2,6,100,200,300},{1,2,7,100,200,300},{1,2,7,100,200,300},{1,2,8,100,200,300},{1,2,9,100,200,300}};
+ var RoSoI vl_badValues := {{1,2,3,4,5,6,7,8,9},
+ {0},{1},{-1},{1000},
+ {1,19},{},{20},{21},{22},{20,21},{22,20},
+ {22,21,100},
+ {2,6,7,8,9,100},{1,6,7,8,9,100}};
+ f_checkSoITemplate(tl_i7sup_1,vl_goodValues,vl_badValues);
+ }
+
+ //=== i8 ===
+ //superset(1,2,(6..9),complement(8,9)) length (4);
+ testcase tc_superset_i8_eq_dyn() runs on A {
+ var template SoI tl_i8sup := superset(all from t_SoI1, complement(8,9)) length (4);
+ f_checkSoITemplateEquivalence(tl_i8sup,t_i8sup_eq);
+ }
+ testcase tc_superset_i8_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i8sup := superset(all from tl_SoI1, complement(8,9)) length (4);
+ f_checkSoITemplateEquivalence(tl_i8sup,t_i8sup_eq);
+ }
+
+ testcase tc_superset_i8_dyn() runs on A {
+ var template SoI tl_i8sup := superset(all from t_SoI1, complement(8,9)) length (4);
+ var RoSoI vl_goodValues := {
+ {1,2,6,6},{1,2,7,6},{1,2,8,6},{1,2,9,6},
+ {1,2,6,7},{1,2,7,7},{1,2,8,7},{1,2,9,7},
+ {1,2,6,10},{1,2,7,10},{1,2,8,10},{1,2,9,10},
+ {1,2,8,6},{1,2,8,7}
+ };
+ var RoSoI vl_badValues := {
+ {1,2,8,9},{1,2,9,9},
+ {1,2,8,9},{1,2,9,9},
+ {1,2,6,10,11},{1,2,7,10,12,13},{1,2,5,10},{1,2,4,10},
+
+ {},
+ {0},{1},{2},{1000},
+ {1,2},{1,6},{20,21},{22,20},
+ {22,21,100},{1,2,6},
+ {1,2,3,4,5,6,7,8,9},
+ {2,6,7,8,9,100},{1,6,7,8,9,100},{1,2,3,4,5,6,7,8,9} };
+ f_checkSoITemplate(tl_i8sup,vl_goodValues,vl_badValues);
+ }
+ testcase tc_superset_i8_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i8sup := superset(all from tl_SoI1, complement(8,9)) length (4);
+ var RoSoI vl_goodValues := {
+ {1,2,6,6},{1,2,7,6},{1,2,8,6},{1,2,9,6},
+ {1,2,6,7},{1,2,7,7},{1,2,8,7},{1,2,9,7},
+ {1,2,6,10},{1,2,7,10},{1,2,8,10},{1,2,9,10},
+ {1,2,8,6},{1,2,8,7}
+ };
+ var RoSoI vl_badValues := {
+ {1,2,8,9},{1,2,9,9},
+ {1,2,8,9},{1,2,9,9},
+ {1,2,6,10,11},{1,2,7,10,12,13},{1,2,5,10},{1,2,4,10},
+
+ {},
+ {0},{1},{2},{1000},
+ {1,2},{1,6},{20,21},{22,20},
+ {22,21,100},{1,2,6},
+ {1,2,3,4,5,6,7,8,9},
+ {2,6,7,8,9,100},{1,6,7,8,9,100},{1,2,3,4,5,6,7,8,9} };
+ f_checkSoITemplate(tl_i8sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i9 ===
+ //superset(complement(1,2,(6..9))) //length (4);
+ // It matches all set of integers which contains at least one integer which is not 1,2,6,7,8 or 9
+ testcase tc_superset_i9_eq_dyn() runs on A {
+ var template SoI tl_i9sup := superset(complement(all from t_SoI1))
+ f_checkSoITemplateEquivalence(tl_i9sup,t_i9sup_eq);
+ }
+ testcase tc_superset_i9_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i9sup := superset(complement(all from tl_SoI1))
+ f_checkSoITemplateEquivalence(tl_i9sup,t_i9sup_eq);
+ }
+
+ testcase tc_superset_i9_dyn() runs on A {
+ var template SoI tl_i9sup := superset(complement(all from t_SoI1))
+ var RoSoI vl_goodValues := {
+ {0,3,4,5},{0,10,11,12},{0},{3},{4},{5},{10},{11},{3,4},{1,2,3},{1,2,6,10},{1,2,6,7,8,9,10}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1,2},{1,6},{1,7},{1,8},{1,9},{2,6},{2,7},{2,8},{2,9},{1,2,6},{1,2,6,9}
+ }
+ f_checkSoITemplate(tl_i9sup,vl_goodValues,vl_badValues);
+ }
+ testcase tc_superset_i9_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i9sup := superset(complement(all from tl_SoI1))
+ var RoSoI vl_goodValues := {
+ {0,3,4,5},{0,10,11,12},{0},{3},{4},{5},{10},{11},{3,4},{1,2,3},{1,2,6,10},{1,2,6,7,8,9,10}
+ };
+ var RoSoI vl_badValues := {
+ {},{1},{2},{6},{7},{8},{9},{1,2},{1,6},{1,7},{1,8},{1,9},{2,6},{2,7},{2,8},{2,9},{1,2,6},{1,2,6,9}
+ }
+ f_checkSoITemplate(tl_i9sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i9sup_1 ===
+ //superset(complement(1,2,(6..9))) length (4);
+ // It matches all set of integers with length 4 which contains at least one integer which is not 1,2,6,7,8 or 9
+ testcase tc_superset_i9_1_eq_dyn() runs on A {
+ var template SoI tl_i9sup_1 := superset(complement(all from t_SoI1)) length (4);
+ f_checkSoITemplateEquivalence(tl_i9sup_1,t_i9sup_1_eq);
+ }
+ testcase tc_superset_i9_1_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i9sup_1 := superset(complement(all from tl_SoI1)) length (4);
+ f_checkSoITemplateEquivalence(tl_i9sup_1,t_i9sup_1_eq);
+ }
+
+ testcase tc_superset_i9_1_dyn() runs on A {
+ var template SoI tl_i9sup_1 := superset(complement(all from t_SoI1)) length (4);
+ var RoSoI vl_goodValues := {
+ {0,3,4,5},{0,10,11,12}, //4matches to compl
+ {1,3,4,5},{2,3,4,5},{6,3,4,5}, //3 matches
+ {1,2,10,11}, //2matches to compl value list
+ {1,2,6,10} //1matches
+ };
+ var RoSoI vl_badValues := {{0},{3},{4},{5},{10},{11},{3,4},{1,2,3},
+ {},{1},{2},{6},{7},{8},{9},{1,2},{1,6},{1,7},{1,8},{1,9},{2,6},{2,7},{2,8},{2,9},{1,2,6},{1,2,6,9},{1,2,6,7,8,9,10}
+ }
+ f_checkSoITemplate(tl_i9sup_1,vl_goodValues,vl_badValues);
+ }
+
+ testcase tc_superset_i9_1_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i9sup_1 := superset(complement(all from tl_SoI1)) length (4);
+ var RoSoI vl_goodValues := {
+ {0,3,4,5},{0,10,11,12}, //4matches to compl
+ {1,3,4,5},{2,3,4,5},{6,3,4,5}, //3 matches
+ {1,2,10,11}, //2matches to compl value list
+ {1,2,6,10} //1matches
+ };
+ var RoSoI vl_badValues := {{0},{3},{4},{5},{10},{11},{3,4},{1,2,3},
+ {},{1},{2},{6},{7},{8},{9},{1,2},{1,6},{1,7},{1,8},{1,9},{2,6},{2,7},{2,8},{2,9},{1,2,6},{1,2,6,9},{1,2,6,7,8,9,10}
+ }
+ f_checkSoITemplate(tl_i9sup_1,vl_goodValues,vl_badValues);
+ }
+
+ //=== i10 ===
+ //superset(1,2,(6..9),complement(1,2,(6..9) )) length (4);
+ //This matches with set of values (with length of 4) which contains at least once values from the list 1,2,(6..9) furthermore one value which does not matches
+ // with that list
+ testcase tc_superset_i10_eq_dyn() runs on A {
+ var template SoI tl_i10sup := superset(all from t_SoI1, complement(all from t_SoI1)) length (4);
+ f_checkSoITemplateEquivalence(tl_i10sup,t_i10sup_eq);
+ }
+
+ testcase tc_superset_i10_eq_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i10sup := superset(all from tl_SoI1, complement(all from tl_SoI1)) length (4);
+ f_checkSoITemplateEquivalence(tl_i10sup,t_i10sup_eq);
+ }
+
+ testcase tc_superset_i10_dyn() runs on A {
+ var template SoI tl_i10sup := superset(all from t_SoI1, complement(all from t_SoI1)) length (4);
+ var RoSoI vl_goodValues := {
+ {1,2,6,10},{1,2,7,11},{1,2,8,-1},{1,2,9,0},{1,2,9,1000}
+ };
+ var RoSoI vl_badValues := {
+ {0},{3},{4},{5},{10},{11},{3,4},{1,2,3},
+ {},{1},{2},{6},{7},{8},{9},{1,2},{1,6},{1,7},{1,8},{1,9},{2,6},{2,7},{2,8},{2,9},{1,2,6},
+ {1,2,6,9},{0,3,4,5},{0,10,11,12}, //4matches to compl
+ {1,3,4,5},{2,3,4,5},{6,3,4,5}, //3 matches{1,2,6,7,8,9,10}
+ {1,3,4,5},
+ {2,3,4,5},
+ {6,3,4,5},
+ {1,2,10,11}
+ }
+ f_checkSoITemplate(tl_i10sup,vl_goodValues,vl_badValues);
+ }
+ testcase tc_superset_i10_2dyn() runs on A {
+ var template SoI tl_SoI1 := {1, 2, (6..9)};
+ var template SoI tl_i10sup := superset(all from t_SoI1, complement(all from t_SoI1)) length (4);
+ var RoSoI vl_goodValues := {
+ {1,2,6,10},{1,2,7,11},{1,2,8,-1},{1,2,9,0},{1,2,9,1000}
+ };
+ var RoSoI vl_badValues := {
+ {0},{3},{4},{5},{10},{11},{3,4},{1,2,3},
+ {},{1},{2},{6},{7},{8},{9},{1,2},{1,6},{1,7},{1,8},{1,9},{2,6},{2,7},{2,8},{2,9},{1,2,6},
+ {1,2,6,9},{0,3,4,5},{0,10,11,12}, //4matches to compl
+ {1,3,4,5},{2,3,4,5},{6,3,4,5}, //3 matches{1,2,6,7,8,9,10}
+ {1,3,4,5},
+ {2,3,4,5},
+ {6,3,4,5},
+ {1,2,10,11}
+ }
+ f_checkSoITemplate(tl_i10sup,vl_goodValues,vl_badValues);
+ }
+
+ //=== i11 ===
+ // superset(1,2,(6..9), complement(1,2)) length (4);
+
+ testcase tc_superset_i11_eq_dyn() runs on A {
+ var template SoI tl_i11sup := superset(all from t_SoI1, complement(all from t_SoI5)) length (4);
+ f_checkSoITemplateEquivalence(tl_i11sup,t_i11sup_eq);
+ }
+
+ testcase tc_superset_i11_dyn() runs on A {
+ var template SoI tl_i11sup := superset(all from t_SoI1, complement(all from t_SoI5)) length (4);
+ var RoSoI vl_goodValues := {
+ {1,2,6,0},{1,2,7,3},{1,2,8,3},{1,2,9,4},{1,2,9,1000}
+ };
+ var RoSoI vl_badValues := {
+ {0},{3},{4},{5},{10},{11},{3,4},{1,2,3},
+ {},{1},{2},{6},{7},{8},{9},{1,2},{1,6},{1,7},{1,8},{1,9},{2,6},{2,7},{2,8},{2,9},{1,2,6},
+ {1,2,6,1},{0,3,4,5},{0,10,11,12},
+ {1,3,4,5},{2,3,4,5},{6,3,4,5},
+ {1,3,4,5},
+ {2,3,4,5},
+ {6,3,4,5},
+ {1,2,10,11}
+ }
+ f_checkSoITemplate(tl_i11sup,vl_goodValues,vl_badValues);
+ }
+
+}
+
+control {
+ execute(tc_superset());
+execute(tc_superset_i0_eq());
+execute(tc_superset_importing_i0_eq());
+execute(tc_superset_i0_eq_local());
+execute(tc_superset_importing_i0_eq_local());
+execute(tc_superset_i0_eq_2local());
+execute(tc_superset_i0());
+execute(tc_superset_importing_i0());
+execute(tc_superset_i0_1_eq());
+execute(tc_superset_i0_1_eq_local());
+execute(tc_superset_i0_1_eq_2local());
+execute(tc_superset_i0_1());
+execute(tc_superset_i0_1_2local());
+execute(tc_superset_i1_eq());
+execute(tc_superset_i1());
+execute(tc_superset_i2_eq());
+execute(tc_superset_i2());
+execute(tc_superset_i3_eq());
+execute(tc_superset_i3());
+execute(tc_superset_i4_eq());
+execute(tc_superset_i4());
+execute(tc_superset_i5_eq());
+execute(tc_superset_i5());
+execute(tc_superset_i6_eq());
+execute(tc_superset_i6());
+execute(tc_superset_i7_eq());
+execute(tc_superset_i7());
+execute(tc_superset_i7_1_eq());
+execute(tc_superset_i7_1());
+execute(tc_superset_i8_eq());
+execute(tc_superset_i8());
+execute(tc_superset_i9_eq());
+execute(tc_superset_i9());
+execute(tc_superset_i9_1_eq());
+execute(tc_superset_i9_1());
+execute(tc_superset_i10_eq());
+execute(tc_superset_i10());
+execute(tc_superset_i11_eq());
+execute(tc_superset_i11());
+execute(tc_superset_i0_eq_dyn());
+execute(tc_superset_importing_i0_eq_dyn());
+execute(tc_superset_i0_eq_2dyn());
+execute(tc_superset_i0_dyn());
+execute(tc_superset_i0_2dyn());
+execute(tc_superset_i1_eq_dyn());
+execute(tc_superset_importing_i1_eq_dyn());
+execute(tc_superset_i1_eq_2dyn());
+execute(tc_superset_i1_dyn());
+execute(tc_superset_i1_2dyn());
+execute(tc_superset_i2_eq_dyn());
+execute(tc_superset_importing_i2_eq_dyn());
+execute(tc_superset_i2_eq_2dyn());
+execute(tc_superset_i2_dyn());
+execute(tc_superset_i2_2dyn());
+execute(tc_superset_i3_eq_dyn());
+execute(tc_superset_i3_eq_2dyn());
+execute(tc_superset_i3_dyn());
+execute(tc_superset_i3_2dyn());
+execute(tc_superset_i4_eq_dyn());
+execute(tc_superset_i4_eq_2dyn());
+execute(tc_superset_i4_dyn());
+execute(tc_superset_i4_2dyn());
+execute(tc_superset_i5_eq_dyn());
+execute(tc_superset_i5_eq_2dyn());
+execute(tc_superset_i5_dyn());
+execute(tc_superset_i5_2dyn());
+execute(tc_superset_i6_eq_dyn());
+execute(tc_superset_i6_dyn());
+execute(tc_superset_i7_eq_dyn());
+execute(tc_superset_i7_eq_2dyn());
+execute(tc_superset_i7_dyn());
+execute(tc_superset_i7_2dyn());
+execute(tc_superset_i7_1_eq_dyn());
+execute(tc_superset_i7_1_eq_2dyn());
+execute(tc_superset_i7_1_dyn());
+execute(tc_superset_i7_1_2dyn());
+execute(tc_superset_i8_eq_dyn());
+execute(tc_superset_i8_eq_2dyn());
+execute(tc_superset_i8_dyn());
+execute(tc_superset_i8_2dyn());
+execute(tc_superset_i9_eq_dyn());
+execute(tc_superset_i9_eq_2dyn());
+execute(tc_superset_i9_dyn());
+execute(tc_superset_i9_2dyn());
+execute(tc_superset_i9_1_eq_dyn());
+execute(tc_superset_i9_1_eq_2dyn());
+execute(tc_superset_i9_1_dyn());
+execute(tc_superset_i9_1_2dyn());
+execute(tc_superset_i10_eq_dyn());
+execute(tc_superset_i10_eq_2dyn());
+execute(tc_superset_i10_dyn());
+execute(tc_superset_i10_2dyn());
+execute(tc_superset_i11_eq_dyn());
+execute(tc_superset_i11_dyn());
+}
+} // end of module
diff --git a/Regression_Test_java/src/all_from/all_from_var.ttcn b/Regression_Test_java/src/all_from/all_from_var.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..3075195d262a22f0c4309d9cfd15a0079e09e4be
--- /dev/null
+++ b/Regression_Test_java/src/all_from/all_from_var.ttcn
@@ -0,0 +1,308 @@
+/******************************************************************************
+ * 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
+ *
+ ******************************************************************************/
+module all_from_var { // HR17266
+
+ import from types all;
+ import from functions all;
+
+ // Testing 'all from' on variables, constants and template variables
+ testcase tc_checkVar() runs on A {
+ var RoI v_roi1 := { 1, 2, 6, 7, 9 };
+ var template integer v_af := ( 8, all from v_roi1 );
+
+ var RoI vl_goodValues := { 1, 2, 6, 7, 8, 9 };
+ var RoI vl_badValues := { -99, -10, -1, 0, 3, 4, 5, 10, 11, 20, 99, 100, 101, 102, 200, 1000, 100000000000000 };
+ f_checkIntegerTemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkConst() runs on A {
+ const RoI c_roi1 := { 1, 2, 6, 7, 9 };
+ var template integer v_af := ( 8, all from c_roi1 );
+
+ var RoI vl_goodValues := { 1, 2, 6, 7, 8, 9 };
+ var RoI vl_badValues := { -99, -10, -1, 0, 3, 4, 5, 10, 11, 20, 99, 100, 101, 102, 200, 1000, 100000000000000 };
+ f_checkIntegerTemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkTempVar() runs on A {
+ var template RoI vt_roi1 := { 1, 2, (6 .. 9) };
+ var template integer v_af := ( 11, all from vt_roi1 );
+
+ var RoI vl_goodValues := { 1, 2, 6, 7, 8, 9 };
+ var RoI vl_badValues := { -99, -10, -1, 0, 3, 4, 5, 10, 20, 99, 100, 101, 102, 200, 1000, 100000000000000 };
+ f_checkIntegerTemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ // Testing the complement of an 'all from' (used on variables, constants and template variables)
+ testcase tc_checkVarComplement() runs on A {
+ var RoI v_roi1 := { 1, 2, 6, 7, 9 };
+ var template integer v_af := complement ( 8, all from v_roi1 );
+
+ var RoI vl_badValues := { 1, 2, 6, 7, 8, 9 };
+ var RoI vl_goodValues := { -99, -10, -1, 0, 3, 4, 5, 10, 11, 20, 99, 100, 101, 102, 200, 1000, 100000000000000 };
+ f_checkIntegerTemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkConstComplement() runs on A {
+ const RoI c_roi1 := { 1, 2, 6, 7, 9 };
+ var template integer v_af := complement ( 8, all from c_roi1 );
+
+ var RoI vl_badValues := { 1, 2, 6, 7, 8, 9 };
+ var RoI vl_goodValues := { -99, -10, -1, 0, 3, 4, 5, 10, 11, 20, 99, 100, 101, 102, 200, 1000, 100000000000000 };
+ f_checkIntegerTemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkTempVarComplement() runs on A {
+ var template RoI vt_roi1 := { 1, 2, (6 .. 9) };
+ var template integer v_af := complement ( 11, all from vt_roi1 );
+
+ var RoI vl_badValues := { 1, 2, 6, 7, 8, 9 };
+ var RoI vl_goodValues := { -99, -10, -1, 0, 3, 4, 5, 10, 20, 99, 100, 101, 102, 200, 1000, 100000000000000 };
+ f_checkIntegerTemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ // Testing the permutation of an 'all from' (used on variables, constants and template variables)
+ testcase tc_checkVarPermutation() runs on A {
+ var RoI v_roi1 := { 1, 2 };
+ var template RoI v_af := { permutation ( 6, all from v_roi1 ), 7 };
+
+ var RoRoI vl_goodValues := { {1, 2, 6, 7}, {1, 6, 2, 7}, {2, 1, 6, 7}, {2, 6, 1, 7}, {6, 1, 2, 7}, {6, 2, 1, 7}};
+ var RoRoI vl_badValues := { {}, {1}, {1, 2, 6}, {1, 2, 7}, {7, 2, 1, 6}, {-5, 1, 2, 6, 7}, {1, 2, 3, 4}, {7, 6}, {19000000000000, 107, 66, 18} }
+ f_checkRoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkConstPermutation() runs on A {
+ const RoI c_roi1 := { 1, 2 };
+ var template RoI v_af := { permutation ( 6, all from c_roi1 ), 7 };
+
+ var RoRoI vl_goodValues := { {1, 2, 6, 7}, {1, 6, 2, 7}, {2, 1, 6, 7}, {2, 6, 1, 7}, {6, 1, 2, 7}, {6, 2, 1, 7}};
+ var RoRoI vl_badValues := { {}, {1}, {1, 2, 6}, {1, 2, 7}, {7, 2, 1, 6}, {-5, 1, 2, 6, 7}, {1, 2, 3, 4}, {7, 6}, {19000000000000, 107, 66, 18} };
+ f_checkRoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkTempVarPermutation() runs on A {
+ var template RoI vt_roi1 := { (1..3), (2..4) };
+ var template RoI v_af := { permutation ( all from vt_roi1 ), 7 };
+
+ var RoRoI vl_goodValues := { {1, 2, 7}, {2, 2, 7}, {3, 2, 7}, {1, 3, 7}, {2, 3, 7}, {3, 3, 7}, {1, 4, 7}, {2, 4, 7}, {3, 4, 7} };
+ var RoRoI vl_badValues := { {}, {1}, {1, 2, 6}, {1, 2, 3, 7}, {7, 2, 1, 6}, {-5, 1, 2, 7}, {1, 2, 3, 4}, {7, 6}, {19000000000000, 107, 66} };
+ f_checkRoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ // Testing the subset of an 'all from' (used on variables, constants and template variables)
+ testcase tc_checkVarSubset() runs on A {
+ var RoI v_roi1 := { 1, 2, 3 };
+ var template SoI v_af := subset (all from v_roi1);
+
+ var RoSoI vl_goodValues := { {}, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2 ,3} };
+ var RoSoI vl_badValues := { {4}, {-8}, {6300000000000000000}, {1, 2, 6}, {1, 2, 3, 6}, {1, 1, 2, 3}, {0, 2, 3}, {100, 77777777777, 45454213414} };
+ f_checkSoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkConstSubset() runs on A {
+ const RoI c_roi1 := { 1, 2, 3 };
+ var template SoI v_af := subset (all from c_roi1);
+
+ var RoSoI vl_goodValues := { {}, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2 ,3} };
+ var RoSoI vl_badValues := { {4}, {-8}, {6300000000000000000}, {1, 2, 6}, {1, 2, 3, 6}, {1, 1, 2, 3}, {0, 2, 3}, {100, 77777777777, 45454213414} };
+ f_checkSoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkTempVarSubset() runs on A {
+ var template RoI vt_roi1 := { 1, (2..4) };
+ var template SoI v_af := subset (all from vt_roi1);
+
+ var RoSoI vl_goodValues := { {}, {1}, {2}, {3}, {4}, {1, 2}, {1, 3}, {1, 4} };
+ var RoSoI vl_badValues := { {-8}, {6300000000000000000}, {2, 3}, {1, 2 ,3}, {1, 2, 6}, {1, 2, 3, 6}, {1, 1, 4}, {0, 2, 3}, {77777777777, 45454213414} };
+ f_checkSoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ // Testing the superset of an 'all from' (used on variables, constants and template variables)
+ testcase tc_checkVarSuperset() runs on A {
+ var RoI v_roi1 := { 1, 2, 3 };
+ var template SoI v_af := superset (all from v_roi1);
+
+ var RoSoI vl_goodValues := { {1, 2, 3}, {1, 2, 3, 0}, {1, 2, 3, 10}, {8, 2, 1, 3}, {3, 2, 1, 0}, {1, 1, 2, 3}, {1, 100, 77777777777, 2, 3, 45454213414} };
+ var RoSoI vl_badValues := { {}, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {4}, {-8}, {6300000000000000000}, {1, 2, 6}, {0, 2, 3}, {100, 77777777777, 45454213414} };
+ f_checkSoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkConstSuperset() runs on A {
+ const RoI c_roi1 := { 1, 2, 3 };
+ var template SoI v_af := superset (all from c_roi1);
+
+ var RoSoI vl_goodValues := { {1, 2, 3}, {1, 2, 3, 0}, {1, 2, 3, 10}, {8, 2, 1, 3}, {3, 2, 1, 0}, {1, 1, 2, 3}, {1, 100, 77777777777, 2, 3, 45454213414} };
+ var RoSoI vl_badValues := { {}, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {4}, {-8}, {6300000000000000000}, {1, 2, 6}, {0, 2, 3}, {100, 77777777777, 45454213414} };
+ f_checkSoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkTempVarSuperset() runs on A {
+ var template RoI vt_roi1 := { 1, (2..4) };
+ var template SoI v_af := superset (all from vt_roi1);
+
+ var RoSoI vl_goodValues := { {1, 2}, {1, 3}, {1, 2, 3}, {1, 3, 0}, {1, 2, 3, 10}, {8, 2, 1}, {3, 2, 1, 0}, {1, 1, 3}, {1, 100, 77777777777, 3, 45454213414} };
+ var RoSoI vl_badValues := { {}, {1}, {2}, {3}, {2, 3}, {4}, {-8}, {6300000000000000000}, {0, 2, 3}, {100, 77777777777, 45454213414}, {7, 6}, {3, 4} };
+ f_checkSoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ // Testing 'all from' on template variables that reference themselves
+ // (same with permutation, subset and superset)
+ testcase tc_checkTempVarSelf() runs on A {
+ var template RoI v_af := { 1, (2..4) };
+ v_af := { 7, (all from v_af) };
+
+ var RoRoI vl_goodValues := { {7, 1}, {7, 2}, {7, 3}, {7, 4} };
+ var RoRoI vl_badValues := { {}, {7}, {1}, {2}, {3}, {4}, {7, 0}, {7, 5}, {7, 10}, {7, 98765432123456789}, {1, 2, 3} };
+ f_checkRoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkTempVarSelfPermutation() runs on A {
+ var template RoI v_af := { (1..3), (2..4) };
+ v_af := { permutation ( all from v_af ), 7 };
+
+ var RoRoI vl_goodValues := { {1, 2, 7}, {2, 2, 7}, {3, 2, 7}, {1, 3, 7}, {2, 3, 7}, {3, 3, 7}, {1, 4, 7}, {2, 4, 7}, {3, 4, 7} };
+ var RoRoI vl_badValues := { {}, {1}, {1, 2, 6}, {1, 2, 3, 7}, {7, 2, 1, 6}, {-5, 1, 2, 7}, {1, 2, 3, 4}, {7, 6}, {19000000000000, 107, 66} };
+ f_checkRoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkTempVarSelfSubset() runs on A {
+ var template SoI v_af := { 1, (2..4) };
+ v_af := subset (all from v_af);
+
+ var RoSoI vl_goodValues := { {}, {1}, {2}, {3}, {4}, {1, 2}, {1, 3}, {1, 4} };
+ var RoSoI vl_badValues := { {-8}, {6300000000000000000}, {2, 3}, {1, 2 ,3}, {1, 2, 6}, {1, 2, 3, 6}, {1, 1, 4}, {0, 2, 3}, {77777777777, 45454213414} };
+ f_checkSoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkTempVarSelfSuperset() runs on A {
+ var template SoI v_af := { 1, (2..4) };
+ v_af := superset (all from v_af);
+
+ var RoSoI vl_goodValues := { {1, 2}, {1, 3}, {1, 2, 3}, {1, 3, 0}, {1, 2, 3, 10}, {8, 2, 1}, {3, 2, 1, 0}, {1, 1, 3}, {1, 100, 77777777777, 3, 45454213414} };
+ var RoSoI vl_badValues := { {}, {1}, {2}, {3}, {2, 3}, {4}, {-8}, {6300000000000000000}, {0, 2, 3}, {100, 77777777777, 45454213414}, {7, 6}, {3, 4} };
+ f_checkSoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ // Testing 'all from' and self referencing on function parameters
+ function f_all_from_par(inout template RoI p_af) runs on A {
+ p_af := { 7, (all from p_af) };
+ }
+
+ testcase tc_checkTempParSelf() runs on A {
+ var template RoI v_af := { 1, (2..4) };
+ f_all_from_par(v_af);
+
+ var RoRoI vl_goodValues := { {7, 1}, {7, 2}, {7, 3}, {7, 4} };
+ var RoRoI vl_badValues := { {}, {7}, {1}, {2}, {3}, {4}, {7, 0}, {7, 5}, {7, 10}, {7, 98765432123456789}, {1, 2, 3} };
+ f_checkRoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ // Testing 'all from' and self referencing on template variables in the parameter lists of
+ // function calls and parametrised templates
+ function f_do_nothing(in template RoI p_temp) runs on A return template RoI {
+ return p_temp;
+ }
+
+ function f_do_nothing2(in template integer p_ti, in template RoI p_temp) runs on A return template RoI {
+ return p_temp;
+ }
+
+ function f_do_nothing_io(inout template RoI p_temp) runs on A return template RoI {
+ return p_temp;
+ }
+
+ testcase tc_checkTempVarFuncSelf() runs on A {
+ var template RoI v_af := { 1, (2..4) };
+ v_af := { 7, ( all from f_do_nothing(v_af) ) };
+
+ var RoRoI vl_goodValues := { {7, 1}, {7, 2}, {7, 3}, {7, 4} };
+ var RoRoI vl_badValues := { {}, {7}, {1}, {2}, {3}, {4}, {7, 0}, {7, 5}, {7, 10}, {7, 98765432123456789}, {1, 2, 3} };
+ f_checkRoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkTempVarFuncSelf2() runs on A {
+ var template RoI v_af := { 1, (2..4) };
+ v_af := { 7, ( all from f_do_nothing_io(v_af) ) };
+
+ var RoRoI vl_goodValues := { {7, 1}, {7, 2}, {7, 3}, {7, 4} };
+ var RoRoI vl_badValues := { {}, {7}, {1}, {2}, {3}, {4}, {7, 0}, {7, 5}, {7, 10}, {7, 98765432123456789}, {1, 2, 3} };
+ f_checkRoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkTempVarFuncSelf3() runs on A {
+ var template RoI v_af := { 1, (2..4) };
+ v_af := { 7, ( all from f_do_nothing2(0, v_af) ) };
+
+ var RoRoI vl_goodValues := { {7, 1}, {7, 2}, {7, 3}, {7, 4} };
+ var RoRoI vl_badValues := { {}, {7}, {1}, {2}, {3}, {4}, {7, 0}, {7, 5}, {7, 10}, {7, 98765432123456789}, {1, 2, 3} };
+ f_checkRoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkTempVarFuncSelf4() runs on A {
+ var template RoI v_af := { 1, (2..4) };
+ v_af := { 7, ( all from f_do_nothing(f_do_nothing2(0, f_do_nothing(f_do_nothing2(7, v_af)))) ) };
+
+ var RoRoI vl_goodValues := { {7, 1}, {7, 2}, {7, 3}, {7, 4} };
+ var RoRoI vl_badValues := { {}, {7}, {1}, {2}, {3}, {4}, {7, 0}, {7, 5}, {7, 10}, {7, 98765432123456789}, {1, 2, 3} };
+ f_checkRoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ template RoI t_pard(in template RoI t_r) := t_r;
+
+ testcase tc_checkTempVarTempPardSelf() runs on A {
+ var template RoI v_af := { 1, (2..4) };
+ v_af := { 7, ( all from t_pard(v_af) ) };
+
+ var RoRoI vl_goodValues := { {7, 1}, {7, 2}, {7, 3}, {7, 4} };
+ var RoRoI vl_badValues := { {}, {7}, {1}, {2}, {3}, {4}, {7, 0}, {7, 5}, {7, 10}, {7, 98765432123456789}, {1, 2, 3} };
+ f_checkRoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ testcase tc_checkTempVarComboSelf() runs on A {
+ var template RoI v_af := { 1, (2..4) };
+ v_af := { 7, ( all from f_do_nothing2(5, t_pard(f_do_nothing(v_af))) ) };
+
+ var RoRoI vl_goodValues := { {7, 1}, {7, 2}, {7, 3}, {7, 4} };
+ var RoRoI vl_badValues := { {}, {7}, {1}, {2}, {3}, {4}, {7, 0}, {7, 5}, {7, 10}, {7, 98765432123456789}, {1, 2, 3} };
+ f_checkRoITemplate(v_af, vl_goodValues, vl_badValues);
+ }
+
+ control {
+ execute(tc_checkVar());
+ execute(tc_checkConst());
+ execute(tc_checkTempVar());
+ execute(tc_checkVarComplement());
+ execute(tc_checkConstComplement());
+ execute(tc_checkTempVarComplement());
+ execute(tc_checkVarPermutation());
+ execute(tc_checkConstPermutation());
+ execute(tc_checkTempVarPermutation());
+ execute(tc_checkVarSubset());
+ execute(tc_checkConstSubset());
+ execute(tc_checkTempVarSubset());
+ execute(tc_checkVarSuperset());
+ execute(tc_checkConstSuperset());
+ execute(tc_checkTempVarSuperset());
+ execute(tc_checkTempVarSelf());
+ execute(tc_checkTempVarSelfPermutation());
+ execute(tc_checkTempVarSelfSubset());
+ execute(tc_checkTempVarSuperset());
+ execute(tc_checkTempParSelf());
+ execute(tc_checkTempVarFuncSelf());
+ execute(tc_checkTempVarFuncSelf2());
+ execute(tc_checkTempVarFuncSelf3());
+ execute(tc_checkTempVarFuncSelf4());
+ execute(tc_checkTempVarTempPardSelf());
+ execute(tc_checkTempVarComboSelf());
+ }
+}
diff --git a/Regression_Test_java/src/all_from/all_from_with_functions.ttcn b/Regression_Test_java/src/all_from/all_from_with_functions.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..2c3145f9cf30c4121a42d4d4749b5d61fc3fd9e4
--- /dev/null
+++ b/Regression_Test_java/src/all_from/all_from_with_functions.ttcn
@@ -0,0 +1,195 @@
+/******************************************************************************
+ * 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
+ *
+ ******************************************************************************/
+module all_from_with_functions {
+
+//for TR: HR91302 - compiler core dump if function called in "all from"
+
+//external function f_ext(in template RoI r) return template RoI;
+
+type record of integer RoI with { encode "JSON" };
+type set of integer SoI;
+
+type record Rec {
+ integer i,
+ charstring s
+}
+type record of Rec RoRec;
+
+function f_dummy(in template RoI r) return template RoI
+{
+ return r;
+}
+
+function f_dummy2(in template RoI r, in template RoI p) return template RoI
+{
+ return p;
+}
+
+function f_set(in template SoI s) return template SoI
+{
+ return s;
+}
+
+function f_rec(in template RoRec tr) return template RoRec
+{
+ return tr;
+}
+
+type port PT_Empty message
+{
+ inout integer;
+} with {extension "internal"}
+
+type component CT_Empty {
+ port PT_Empty pt;
+}
+
+function square(in integer i) return integer {
+ return i * i;
+}
+
+template RoI t_roi(integer i) := { 1, 2, 3, i };
+template RoI t_roi2(integer i) := { 1, 2, 3, square(i) }
+
+testcase tc_all_from_with_functions() runs on CT_Empty {
+ var template RoI t1 := { permutation ( all from f_dummy2( {1, 2}, {3, 4} ) ) };
+ var template RoI t2 := f_dummy2( { 1, 2}, {3, 4} );
+ var template RoI t3 := { permutation (all from t2) };
+// var template RoI t4 := { permutation ( all from f_ext( {1, 2} ) ) };
+ var template integer t5 := (1, 2, all from f_dummy( {1, 2, (6..9)} ), 10);
+ var template integer t6 := complement (1, 2, all from f_dummy( {1, 2, (6..9)} ), 10);
+ var template SoI t7 := subset (1, 2, all from f_dummy( {3, 4} ), 5) length (2..3);
+ var template SoI t8 := superset (1, 2, all from f_dummy( {3, 4} ), 5) length (6..8);
+ var template integer t9 := (1, 2, all from f_set( {3, 4} ), 6);
+ var template SoI t10 := { t9, ( all from f_set( { (20..30) } ) ) };
+ var template Rec t11 := ( {10, "ten"}, all from f_rec( { {1, "one"}, {2, "two"}, {3, "three"} } ) );
+ var template integer t12 := ( all from t_roi(6) );
+ var template integer t13 := ( all from t_roi2(4) );
+
+ //log("t1=", t1);
+ //log("t2=", t2);
+ //log("t3=", t3);
+ //log("t4=", t4);
+ //log("t5=", t5);
+ //log("t6=", t6);
+ //log("t7=", t7);
+ //log("t8=", t8);
+ //log("t9=", t9);
+ //log("t10=", t10);
+ //log("t11=", t11);
+ //log("t12=", t12);
+ //log("t13=", t13);
+
+ if (log2str(t1) == "{ permutation(3, 4) }" and log2str(t2) == "{ 3, 4 }" and
+ log2str(t3) == "{ permutation(3, 4) }" /*and log2str(t4) == "{ permutation(1, 2) }"*/ and
+ log2str(t5) == "(1, 2, 1, 2, (6 .. 9), 10)" and
+ log2str(t6) == "complement(1, 2, 1, 2, (6 .. 9), 10)" and
+ log2str(t7) == "subset(1, 2, 3, 4, 5) length (2 .. 3)" and
+ log2str(t8) == "superset(1, 2, 3, 4, 5) length (6 .. 8)" and
+ log2str(t9) == "(1, 2, 3, 4, 6)" and log2str(t10) == "{ (1, 2, 3, 4, 6), ((20 .. 30)) }" and
+ log2str(t11) == "({ i := 10, s := \"ten\" }, { i := 1, s := \"one\" }, " &
+ "{ i := 2, s := \"two\" }, { i := 3, s := \"three\" })" and
+ log2str(t12) == "(1, 2, 3, 6)" and log2str(t13) == "(1, 2, 3, 16)")
+ { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+// all from with function (formal) parameters
+function f_all_from_params(in RoI p_in, inout RoI p_inout,
+ in template RoI pt_in, inout template RoI pt_inout)
+ runs on CT_Empty
+ return template integer {
+ return (1, 2, all from p_in, all from p_inout, all from pt_in, all from pt_inout);
+}
+
+testcase tc_all_from_func_params() runs on CT_Empty {
+ const RoI c_twenties := { 20, 21, 22 };
+ var RoI v_thirties := { 30, 31, 32, 33 };
+ template RoI t_fifties := { 50, 56, 59 };
+ var template RoI vt_sixties := { 63, 64, 66, 67 };
+
+ var template integer vt_res := f_all_from_params(c_twenties, v_thirties, t_fifties, vt_sixties);
+ const charstring c_res_log := "(1, 2, 20, 21, 22, 30, 31, 32, 33, 50, 56, 59, 63, 64, 66, 67)";
+ if (log2str(vt_res) == c_res_log) { setverdict(pass); }
+ else { setverdict(fail, "Expected: ", c_res_log, ", got: ", vt_res); }
+}
+
+function f_non_templ(in RoI x) return RoI
+{
+ return x;
+}
+
+//external function f_dec_roi(in octetstring os) return RoI
+// with { extension "prototype(convert) decode(JSON)" }
+
+// all from used on regular (non-template) functions
+//testcase tc_all_from_with_functions2() runs on CT_Empty
+//{
+// var template RoI vt_func_roi := { permutation ( all from f_non_templ( { 1, 4, 7, 10 } ) ) };
+// var template integer vt_func_int := ( 0, 1, all from f_non_templ( { 3, 6, 9 } ) );
+//
+// var octetstring v_enc := char2oct("[ 4, 2, 10, 100 ]");
+// var template RoI vt_ext_func_roi := { permutation ( all from f_dec_roi(v_enc) ) };
+// var template integer vt_ext_func_int := ( 0, 1, all from f_dec_roi(v_enc) );
+//
+// var charstring v_res_log := "{ permutation(1, 4, 7, 10) }";
+// if (log2str(vt_func_roi) != v_res_log) {
+// setverdict(fail, "Expected: ", v_res_log, ", got: ", vt_func_roi);
+// }
+//
+// v_res_log := "(0, 1, 3, 6, 9)";
+// if (log2str(vt_func_int) != v_res_log) {
+// setverdict(fail, "Expected: ", v_res_log, ", got: ", vt_func_int);
+// }
+//
+// v_res_log := "{ permutation(4, 2, 10, 100) }";
+// if (log2str(vt_ext_func_roi) != v_res_log) {
+// setverdict(fail, "Expected: ", v_res_log, ", got: ", vt_ext_func_roi);
+// }
+//
+// v_res_log := "(0, 1, 4, 2, 10, 100)";
+// if (log2str(vt_ext_func_int) != v_res_log) {
+// setverdict(fail, "Expected: ", v_res_log, ", got: ", vt_ext_func_int);
+// }
+//
+// setverdict(pass);
+//}
+
+// all from used in function actual parameters
+template RoI t := { 6, 8 };
+template RoI t_func_par := f_dummy( { 1, 2, all from t });
+template RoI t_func_par_exp := { 1, 2, 6, 8 };
+
+testcase tc_all_from_func_params2() runs on CT_Empty
+{
+ if (log2str(t_func_par) != log2str(t_func_par_exp)) {
+ setverdict(fail, "Template test failed. Expected: ", t_func_par_exp, ", got: ", t_func_par);
+ }
+
+ var template RoI vt_func_par := f_dummy( { 1, 2, all from t });
+ if (log2str(vt_func_par) != log2str(t_func_par_exp)) {
+ setverdict(fail, "Var template test failed. Expected: ", t_func_par_exp, ", got: ", vt_func_par);
+ }
+
+ setverdict(pass);
+}
+
+
+control {
+ execute(tc_all_from_with_functions());
+ execute(tc_all_from_func_params());
+// execute(tc_all_from_with_functions2());
+ execute(tc_all_from_func_params2());
+}
+
+}
diff --git a/Regression_Test_java/src/all_from/everything.ttcn b/Regression_Test_java/src/all_from/everything.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..a9045ba2003d5b731b5512fc242527e0210240dc
--- /dev/null
+++ b/Regression_Test_java/src/all_from/everything.ttcn
@@ -0,0 +1,317 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module everything
+{
+type record of integer RoI;
+type set of integer SoI;
+
+type set of integer MySetOfType (0 .. 10);
+
+type component A {}
+
+/****************************************************************/
+
+// B 1.2.1 Template List
+
+template RoI t_RoI1 := {1, 2, (6..9)};
+template RoI t_RoI2 := {1, *, 3};
+
+template integer t_i1 := (all from t_RoI1, 100);
+// equivalent to (1, 2, (6..9) , 100);
+
+testcase tc1() runs on A
+{
+ var integer v_i;
+ action("t_i1=", t_i1);
+
+ v_i := 1;
+ if (match(v_i, t_i1)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should match ", t_i1); }
+
+ v_i := 2;
+ if (match(v_i, t_i1)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should match ", t_i1); }
+
+ v_i := 3;
+ if (not match(v_i, t_i1)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should NOT match ", t_i1); }
+
+ v_i := 4;
+ if (not match(v_i, t_i1)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should NOT match ", t_i1); }
+
+ v_i := 5;
+ if (not match(v_i, t_i1)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should NOT match ", t_i1); }
+
+ v_i := 6;
+ if (match(v_i, t_i1)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should match ", t_i1); }
+
+ v_i := 10;
+ if (not match(v_i, t_i1)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should NOT match ", t_i1); }
+
+ v_i := 100;
+ if (match(v_i, t_i1)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should match ", t_i1); }
+}
+
+// now correctly reported by Titan
+//template integer t_i2 := (0, all from t_RoI2); // causes an error because t_RoI2 contains AnyElementsOrNone
+
+//testcase tc2() runs on A
+//{
+// action ("t_i2=", t_i2)
+//}
+
+/* TODO: different errors are reported
+template RoI t_RoI3 := (all from t_RoI1); // causes an error because member type of
+ // t_RoI1 (integer) is not compatible with the list template type (RoI)
+
+template RoI t_RoI4 := ?;
+
+template RoI t_RoI5 := (all from t_RoI4); // causes an error because t_RoI4 resolves into a matching mechanism
+*/
+
+//template RoI t_RoI1 := {1, 2, (6..9)};
+//template RoI t_RoI2 := {1, *, 3};
+
+// B 1.2.2 Complemented Template List
+/*
+template RoI t_RoI1c := {1, 2, (6..9)};
+template RoI t_RoI2c := {1, *, 3};
+*/
+template integer t_i1c := complement(all from t_RoI1, 100); // results in (1, 2, (6..9), 100)
+
+// This is exactly the opposite of the testcase in all_from
+testcase tc_compl() runs on A
+{
+ var integer v_i;
+ action("t_i1c=", t_i1c);
+
+ v_i := 1;
+ if (not match(v_i, t_i1c)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should NOT match ", t_i1c); }
+
+ v_i := 2;
+ if (not match(v_i, t_i1c)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should NOT match ", t_i1c); }
+
+ v_i := 3;
+ if (match(v_i, t_i1c)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should match ", t_i1c); }
+
+ v_i := 4;
+ if (match(v_i, t_i1c)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should match ", t_i1c); }
+
+ v_i := 5;
+ if (match(v_i, t_i1c)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should match ", t_i1c); }
+
+ v_i := 6;
+ if (not match(v_i, t_i1c)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should NOT match ", t_i1c); }
+
+ v_i := 10;
+ if (match(v_i, t_i1c)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should match ", t_i1c); }
+
+ v_i := 100;
+ if (not match(v_i, t_i1c)) { setverdict(pass); }
+ else { setverdict(fail, v_i, " should NOT match ", t_i1c); }
+}
+
+// correctly diagnosed by Titan
+//template integer t_i2c := complement(0, all from t_RoI2); // causes an error because t_RoI2 contains AnyElementsOrNone
+
+//template RoI t_RoI3c := complement(all from t_RoI1); // causes an error because member type of t_RoI1 (integer) is not compatible
+// // with the complemented list template type (RoI)
+//
+// The errors for the above are the same as the errors for the one below :)
+//
+//template RoI t_RoI3c_direct := complement(1, 2, (6..9))
+
+/*
+template RoI t_RoI4c := ?;
+template RoI t_RoI5c := complement (all from t_RoI4c);
+ // causes an error because t_RoI4 resolves into a matching mechanism
+ // now correctly signalled by titan
+*/
+//template RoI t_RoI1 := {1, 2, (6..9)};
+//template RoI t_RoI2 := {1, *, 3};
+
+// B 1.2.6 Superset
+
+//EXAMPLE 1:
+
+ template MySetOfType MyTemplate1 := superset (1, 2, 3);
+ // matches any sequence of integers which contains at least one occurrences of the numbers
+ // 1, 2 and 3 in any order and position
+
+ template MySetOfType MyTemplate2_AnyValue := superset (1, 2, ?);
+ // matches any sequence of integers which contains at least one occurrences of the numbers
+ // 1, 2 and at least one more valid integer value (i.e. between 0 and 10, inclusively), in any
+ // order and position
+
+ template MySetOfType MyTemplate3 := superset (1, 2, (3, 4));
+ // matches any sequence of integers which contains at least one occurrences of the numbers
+ // 1, 2 and a number with the value 3 or 4, in any order and position
+
+ template MySetOfType MyTemplate4 := superset (1, 2, complement(3, 4));
+ // any sequence of integers matches which contains at least one occurrences of the numbers
+ // 1, 2 and a valid integer value which is not 3 or 4, in any order and position
+
+ template MySetOfType MyTemplate6 := superset (1, 2, 3) length (7);
+ // matches any sequence of 7 integers which contains at least one occurrences of the numbers
+ // 1, 2 and 3 in any order and position
+
+ template MySetOfType MyTemplate7 := superset (1, 2, ?) length (7 .. infinity);
+ // matches any sequence of at least 7 integers which contains at least one occurrences of the
+ // numbers 1, 2 and 3 in any order and position
+
+ template MySetOfType MyTemplate8 := superset (1, 2, 3) length (2 .. 7);
+ // causes an error, the lower bound of the length attribute contradicts to the minimum number
+ // of elements imposed by the superset argument
+
+//EXAMPLE 2:
+ template RoI t_RoI1s := {1, 2, ?};
+ template SoI t_SoI1s := superset(all from t_RoI1s);
+ // results in superset(1, 2, ?)
+
+testcase tc_superset() runs on A
+{
+ action("superset: ", t_SoI1s);
+}
+
+//template RoI t_RoI1 := {1, 2, (6..9)};
+//template RoI t_RoI2 := {1, *, 3};
+
+// B.1.2.7 SubSet
+//EXAMPLE 1:
+ template MySetOfType MyTemplate1_ := subset (1, 2, 3);
+ // matches any sequence of integers which contains zero or one occurrences of the numbers
+ // 1, 2 and 3 in any order and position
+
+ template MySetOfType MyTemplate2_ := subset (1, 2, ?);
+ // matches any sequence of integers which contains zero or one occurrences of the numbers
+ // 1, 2 and a valid integer value (i.e. between 0 and 10, inclusive) in any order and position
+
+ template MySetOfType MyTemplate3_ := subset (1, 2, (3, 4));
+ // matches any sequence of integers which contains zero or one occurrences of the numbers
+ // 1, 2 and one of the numbers 3 or 4, in any order and position
+
+ template MySetOfType MyTemplate4_ := subset (1, 2, complement (3, 4));
+ // matches any sequence of integers which contains zero or one occurrences of the numbers
+ // 1, 2 and a valid integer number which is not 3 or 4, in any order and position
+
+ template MySetOfType MyTemplate5_ := subset (1, 2, 3) length (2);
+ // matches any sequence of two integers which contains zero or one occurrences of
+ // the numbers 1, 2 and 3, in any order and position
+
+ template MySetOfType MyTemplate6_ := subset (1, 2, ?) length (0 .. 2);
+ // matches any sequence of zero, one or two integers which contains zero or one occurrences of
+ // the numbers 1, 2 and of a valid integer value, in any order and position
+
+ template MySetOfType MyTemplate7_ := subset (1, 2, 3) length (0 .. 4);
+ // causes an error, the upper bound of length attribute contradicts to the maximum number of
+ // elements imposed by the subset argument
+
+//EXAMPLE 2:
+ template RoI t_RoI1_ := {1, 2, ?};
+ template SoI t_SoI1_ := subset(all from t_RoI1_);
+ // results in subset(1, 2, ?)
+
+testcase tc_subset() runs on A
+{
+ action("subset: ", t_SoI1_);
+}
+
+//template RoI t_RoI1 := {1, 2, (6..9)};
+//template RoI t_RoI2 := {1, *, 3};
+
+// B.1.3.3 Permutation
+//EXAMPLE 1:
+ type RoI MySequenceOfType;
+
+ template MySequenceOfType MyTemplate1p := { permutation ( 1, 2, 3 ), 5 };
+ // matches any of the following sequences of 4 integers: 1,2,3,5; 1,3,2,5; 2,1,3,5;
+ // 2,3,1,5; 3,1,2,5; or 3,2,1,5
+
+ template MySequenceOfType MyTemplate2p := { permutation ( 1, 2, ? ), 5 };
+ // matches any sequence of 4 integers that ends with 5 and contains 1 and 2 at least once in
+ // other positions
+
+ template MySequenceOfType MyTemplate3p := { permutation ( 1, 2, 3 ), * };
+ // matches any sequence of integers starting with 1,2,3; 1,3,2; 2,1,3; 2,3,1; 3,1,2 or 3,2,1
+
+ template MySequenceOfType MyTemplate4p := { *, permutation ( 1, 2, 3 )};
+ // matches any sequence of integers ending with 1,2,3; 1,3,2; 2,1,3; 2,3,1; 3,1,2 or 3,2,1
+
+ template MySequenceOfType MyTemplate5p := { *, permutation ( 1, 2, 3 ),* };
+ // matches any sequence of integers containing any of the following substrings at any position:
+ // 1,2,3; 1,3,2; 2,1,3; 2,3,1; 3,1,2 or 3,2,1
+
+ template MySequenceOfType MyTemplate6p := { permutation ( 1, 2, * ), 5 };
+ // matches any sequence of integers that ends with 5 and containing 1 and 2 at least once in
+ // other positions
+
+//error by Titan: Length restriction cannot be used in a template of type `integer'
+// template MySequenceOfType MyTemplate7p := { permutation ( 1, 2, 3 ), * length (0..5) };
+ // matches any sequence of three to eight integers starting with 1,2,3; 1,3,2; 2,1,3; 2,3,1;
+ // 3,1,2 or 3,2,1
+
+ template integer MyInt1 := (1,2,3);
+ template integer MyInt2 := (1,2,?);
+ template integer MyInt3 := ?;
+ template integer MyInt4 := *;
+
+ template MySequenceOfType MyTemplate10 := { permutation (MyInt1, 2, 3 ), 5 };
+ // matches any of the sequences of 4 integers:
+ // 1,3,2,5; 2,1,3,5; 2,3,1,5; 3,1,2,5; or 3,2,1,5;
+ // 2,3,2,5; 2,2,3,5; 2,3,2,5; 3,2,2,5; or 3,2,2,5;
+ // 3,3,2,5; 2,3,3,5; 2,3,3,5; 3,3,2,5; or 3,2,3,5;
+
+ template MySequenceOfType MyTemplate11 := { permutation (MyInt2, 2, 3 ), 5 };
+ // matches any sequence of 4 integers that ends with 5 and contains 2 and 3 at least once in
+ // other positions
+
+ template MySequenceOfType MyTemplate12 := { permutation (MyInt3, 2, 3 ), 5 };
+ // matches any sequence of 4 integers that ends with 5 and contains 2 and 3 at least once in
+ // other positions
+
+ template MySequenceOfType MyTemplate13 := { permutation (MyInt4, 2, 3 ), 5 };
+ // matches any sequence of integers that ends with 5 and containing 2 and 3 at least once in
+ // other positions
+
+ template MySequenceOfType MyTemplate14 := { permutation (MyInt3, 2, ? ), 5 };
+ // matches any sequence of 4 integers that ends with 5 and contains 2 at least once in
+ // other positions
+
+ template MySequenceOfType MyTemplate15 := { permutation (MyInt4, 2, * ), 5 };
+ // matches any sequence of integers that ends with 5 and contains 2 at least once in
+ // other positions
+
+//EXAMPLE 2:
+ template RoI t_RoI1p := {1, 2, *};
+ template RoI t_RoI2p := {permutation(0, all from t_RoI1p), 4, 5};
+ // results in {permutation(0, 1, 2, *), 4, 5}
+
+testcase tc_permut() runs on A
+{
+ action("permut: ", t_RoI2p);
+}
+
+
+} // end of module
diff --git a/Regression_Test_java/src/all_from/functions.ttcn b/Regression_Test_java/src/all_from/functions.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..babedf9c38db9b528d4f89cf7f8b174112963388
--- /dev/null
+++ b/Regression_Test_java/src/all_from/functions.ttcn
@@ -0,0 +1,234 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module functions {
+import from types all;
+
+//************************* Functions ******************************
+
+
+function f_checkIntegerTemplate(in template integer pl_template,in RoI pl_goodValues, in RoI pl_badValues) {
+
+ action("template=", pl_template, " will be checked against ",pl_goodValues);
+
+ var integer N:=sizeof(pl_goodValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (match(pl_goodValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_goodValues[i], " should match ", pl_template); }
+ }
+
+ action("template=", pl_template, " will be checked against ",pl_badValues);
+ N:=sizeof(pl_badValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (not match(pl_badValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_badValues[i], " should not match ", pl_template); }
+ }
+
+}
+with { extension "transparent" }
+
+function f_checkCharstringTemplate(in template charstring pl_template,in RoCS pl_goodValues, in RoCS pl_badValues) {
+
+ action("template=", pl_template, " will be checked against ",pl_goodValues);
+
+ var integer N:=sizeof(pl_goodValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (match(pl_goodValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_goodValues[i], " should match ", pl_template); }
+ }
+
+ action("template=", pl_template, " will be checked against ",pl_badValues);
+ N:=sizeof(pl_badValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (not match(pl_badValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_badValues[i], " should not match ", pl_template); }
+ }
+
+}
+with { extension "transparent" }
+
+function f_checkOctetstringTemplate(in template octetstring pl_template,in RoOS pl_goodValues, in RoOS pl_badValues) {
+
+ action("template=", pl_template, " will be checked against ",pl_goodValues);
+
+ var integer N:=sizeof(pl_goodValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (match(pl_goodValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_goodValues[i], " should match ", pl_template); }
+ }
+
+ action("template=", pl_template, " will be checked against ",pl_badValues);
+ N:=sizeof(pl_badValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (not match(pl_badValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_badValues[i], " should not match ", pl_template); }
+ }
+
+}
+function f_checkRoITemplate(in template RoI pl_template,in RoRoI pl_goodValues, in RoRoI pl_badValues) {
+
+ action("template=", pl_template, " will be checked against ",pl_goodValues);
+
+ var integer N:=sizeof(pl_goodValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (match(pl_goodValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_goodValues[i], " should match ", pl_template); }
+ }
+
+ action("template=", pl_template, " will be checked against ",pl_badValues);
+ N:=sizeof(pl_badValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (not match(pl_badValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_badValues[i], " should not match ", pl_template); }
+ }
+
+}
+with { extension "transparent" }
+
+function f_checkSoITemplate(in template SoI pl_template,in RoSoI pl_goodValues, in RoSoI pl_badValues) {
+
+ action("template=", pl_template, " will be checked against ",pl_goodValues);
+
+ var integer N:=sizeof(pl_goodValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (match(pl_goodValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_goodValues[i], " should match ", pl_template); }
+ }
+
+ action("template=", pl_template, " will be checked against ",pl_badValues);
+ N:=sizeof(pl_badValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (not match(pl_badValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_badValues[i], " should not match ", pl_template); }
+ }
+
+}
+with { extension "transparent" }
+
+function f_checkMyRecTemplate(in template MyRecord pl_template,in RoMyRec pl_goodValues, in RoMyRec pl_badValues) {
+
+ action("template=", pl_template, " will be checked against ",pl_goodValues);
+
+ var integer N:=sizeof(pl_goodValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (match(pl_goodValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_goodValues[i], " should match ", pl_template); }
+ }
+
+ action("template=", pl_template, " will be checked against ",pl_badValues);
+ N:=sizeof(pl_badValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (not match(pl_badValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_badValues[i], " should not match ", pl_template); }
+ }
+
+}
+
+function f_checkMyUnionTemplate(in template MyUnion pl_template,in RoMyUnion pl_goodValues, in RoMyUnion pl_badValues) {
+
+ action("template=", pl_template, " will be checked against ",pl_goodValues);
+
+ var integer N:=sizeof(pl_goodValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (match(pl_goodValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_goodValues[i], " should match ", pl_template); }
+ }
+
+ action("template=", pl_template, " will be checked against ",pl_badValues);
+ N:=sizeof(pl_badValues);
+ for(var integer i:=0;i<N;i:=i+1) {
+ if (not match(pl_badValues[i], pl_template)) { setverdict(pass); }
+ else { setverdict(fail,pl_badValues[i], " should not match ", pl_template); }
+ }
+
+}
+//==== Equivalence ====
+
+function f_checkSoITemplateEquivalence(in template SoI pl_template1, in template SoI pl_template2) {
+ action("template1=",pl_template1," check against ",pl_template2);
+ if(log2str(pl_template1)==log2str(pl_template2)) {setverdict(pass);} else {setverdict(fail,"template1=",pl_template1," should match against ",pl_template2 );}
+}
+with { extension "transparent" }
+
+function f_checkRoITemplateEquivalence(in template RoI pl_template1, in template RoI pl_template2) {
+ action("template1=",pl_template1," check against ",pl_template2);
+ if(log2str(pl_template1)==log2str(pl_template2)) {setverdict(pass);} else {setverdict(fail,"template1=",pl_template1," should match against ",pl_template2 );}
+}
+with { extension "transparent" }
+
+function f_checkRoCSTemplateEquivalence(in template RoCS pl_template1, in template RoCS pl_template2) {
+ action("template1=",pl_template1," check against ",pl_template2);
+ if(log2str(pl_template1)==log2str(pl_template2)) {setverdict(pass);} else {setverdict(fail,"template1=",pl_template1," should match against ",pl_template2 );}
+}
+function f_checkIntTemplateEquivalence(in template integer pl_template1, in template integer pl_template2) {
+ action("template1=",pl_template1," check against ",pl_template2);
+ if(log2str(pl_template1)==log2str(pl_template2)) {setverdict(pass);} else {setverdict(fail,"template1=",pl_template1," should match against ",pl_template2 );}
+}
+with { extension "transparent" }
+
+function f_checkCharstringTemplateEquivalence(in template charstring pl_template1, in template charstring pl_template2) {
+ action("template1=",pl_template1," check against ",pl_template2);
+ if(log2str(pl_template1)==log2str(pl_template2)) {setverdict(pass);} else {setverdict(fail,"template1=",pl_template1," should match against ",pl_template2 );}
+}
+with { extension "transparent" }
+
+function f_checkOctetstringTemplateEquivalence(in template octetstring pl_template1, in template octetstring pl_template2) {
+ action("template1=",pl_template1," check against ",pl_template2);
+ if(log2str(pl_template1)==log2str(pl_template2)) {setverdict(pass);} else {setverdict(fail,"template1=",pl_template1," should match against ",pl_template2 );}
+}
+with { extension "transparent" }
+
+function f_checkMyRecordTemplateEquivalence(in template MyRecord pl_template1, in template MyRecord pl_template2) {
+ action("template1=",pl_template1," check against ",pl_template2);
+ if(log2str(pl_template1)==log2str(pl_template2)) {setverdict(pass);} else {setverdict(fail,"template1=",pl_template1," should match against ",pl_template2 );}
+}
+with { extension "transparent" }
+
+function f_checkMyUnionTemplateEquivalence(in template MyUnion pl_template1, in template MyUnion pl_template2) {
+ action("template1=",pl_template1," check against ",pl_template2);
+ if(log2str(pl_template1)==log2str(pl_template2)) {setverdict(pass);} else {setverdict(fail,"template1=",pl_template1," should match against ",pl_template2 );}
+}
+with { extension "transparent" }
+
+function f_checkMyFunctionRefTemplateEquivalence(in template F_int2int pl_template1, in template F_int2int pl_template2) {
+ action("template1=",pl_template1," check against ",pl_template2);
+ if(log2str(pl_template1)==log2str(pl_template2)) {setverdict(pass);} else {setverdict(fail,"template1=",pl_template1," should match against ",pl_template2 );}
+}
+with { extension "transparent" }
+
+function f_checkMyRoFRefTemplateEquivalence(in template RoF_int2int pl_template1, in template RoF_int2int pl_template2) {
+ action("template1=",pl_template1," check against ",pl_template2);
+ if(log2str(pl_template1)==log2str(pl_template2)) {setverdict(pass);} else {setverdict(fail,"template1=",pl_template1," should match against ",pl_template2 );}
+}
+with { extension "transparent" }
+
+function f_createIntegerWithAllFromFromInTemplateFromRoi(in template RoI pl_template1, inout template integer pl_template2) {
+ pl_template2:= (all from pl_template1);
+}
+
+function f_createIntegerWithAllFromFromInOutTemplateFromRoi(inout template RoI pl_template1, inout template integer pl_template2) {
+ pl_template2:= (all from pl_template1);
+}
+
+function f_createIntegerWithAllFromFromInTemplateFromSoi(in template SoI pl_template1, inout template integer pl_template2) {
+ pl_template2:= (all from pl_template1);
+}
+
+function f_createIntegerWithAllFromFromInOutTemplateFromSoi(inout template SoI pl_template1, inout template integer pl_template2) {
+ pl_template2:= (all from pl_template1);
+}
+
+//====== function references =======
+function f_int2int_1(in integer pl_i) return integer { log("f_int2int_1 called with ", pl_i);return 1;}
+function f_int2int_2(in integer pl_i) return integer { log("f_int2int_2 called with ", pl_i);return 2;}
+
+}//module
diff --git a/Regression_Test_java/src/all_from/imported_templates.ttcn b/Regression_Test_java/src/all_from/imported_templates.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..e51e479ca504397476ea720a1427f207a6e5112e
--- /dev/null
+++ b/Regression_Test_java/src/all_from/imported_templates.ttcn
@@ -0,0 +1,32 @@
+/******************************************************************************
+ * 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
+ *
+ ******************************************************************************/
+module imported_templates {
+
+import from types all;
+//===== Templates for use by all_from from another module
+
+//============Record of Integer============================
+//for value list and for complement:
+template RoI t_imported_RoI1 := {1, 2, (6..9)};
+template RoI t_imported_RoI2 := {1, *, 3};
+template RoI t_imported_RoI3 := {20,21,22};
+template RoI t_imported_RoI4 := {1, ?, 3};
+//for permutation:
+template RoI t_imported_RoI1_P := {1, 2, *};
+template RoI t_imported_RoI3_P := {1, 2, 3};
+template RoI t_imported_RoI7_P := {1, 2, ?};
+
+//===========Set of Integer================================
+template SoI t_imported_SoI1 := {1,2,(6..9)};
+template SoI t_imported_SoI2 := {1, *, 3};
+template SoI t_imported_SoI3 := {20,21,22};
+}
diff --git a/Regression_Test_java/src/all_from/sapc.ttcn b/Regression_Test_java/src/all_from/sapc.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..b6426c039173652838f82c447bce38bb57f1813a
--- /dev/null
+++ b/Regression_Test_java/src/all_from/sapc.ttcn
@@ -0,0 +1,110 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module sapc {
+import from types all;
+type component sapka {}
+
+template CreateSAPCSubscription t_sapc_data := {
+ pcBlacklistService_list := { "a", "b", "c" }
+}
+
+template GetResponseSAPCSubscription g_resp := {
+permutation(
+"hello",
+all from t_sapc_data.pcBlacklistService_list
+)
+};
+
+testcase tc_sapc() runs on sapka
+{
+var template CreateSAPCSubscription vt_sapc_data := t_sapc_data
+
+// compiler doesn't let us compare templates :(
+//if (t_sapc_data==vt_sapc_data) { setverdict(pass); } else { setverdict(fail); }
+if (log2str(t_sapc_data)==log2str(vt_sapc_data)) { setverdict(pass); } else { setverdict(fail); }
+
+var template GetResponseSAPCSubscription resp; // initialized from a template
+var template GetResponseSAPCSubscription resp_vt; // from a var template
+var template GetResponseSAPCSubscription resp_manual; // hacked by hand
+
+if (sizeof (vt_sapc_data.pcBlacklistService_list) > 0) {
+ select (sizeof (vt_sapc_data.pcBlacklistService_list)){
+ case (1) {
+ resp_manual.pcBlacklistService_list := {
+ permutation("hello", vt_sapc_data.pcBlacklistService_list[0], "goodbye")
+ }
+ }
+ case (2) {
+ resp_manual.pcBlacklistService_list := {
+ permutation ("hello",
+ vt_sapc_data.pcBlacklistService_list[0],
+ vt_sapc_data.pcBlacklistService_list[1], "goodbye")
+ }
+ }
+ case (3) {
+ resp_manual.pcBlacklistService_list := {
+ permutation ("hello",
+ vt_sapc_data.pcBlacklistService_list[0],
+ vt_sapc_data.pcBlacklistService_list[1],
+ vt_sapc_data.pcBlacklistService_list[2], "goodbye")
+ }
+ }
+ case else {
+ resp_manual.pcBlacklistService_list := {
+ permutation ("hello",
+ vt_sapc_data.pcBlacklistService_list[0],
+ vt_sapc_data.pcBlacklistService_list[1],
+ vt_sapc_data.pcBlacklistService_list[2],
+ vt_sapc_data.pcBlacklistService_list[3], "goodbye",
+ *)
+ }
+ }
+ }
+}
+
+// var template referring to a global template
+resp.pcBlacklistService_list := {
+permutation(
+"hello",
+all from t_sapc_data .pcBlacklistService_list,
+"goodbye"
+) };
+
+// var template referring to another var template
+resp_vt.pcBlacklistService_list := {
+permutation(
+"hello",
+all from vt_sapc_data .pcBlacklistService_list,
+"goodbye"
+) };
+
+action("manual ", resp_manual.pcBlacklistService_list);
+action("all ", resp .pcBlacklistService_list);
+action("all vt ", resp_vt .pcBlacklistService_list);
+
+if (log2str(resp.pcBlacklistService_list)==log2str(resp_manual.pcBlacklistService_list))
+{ setverdict(pass); } else { setverdict(fail, "at line ", __LINE__, "\n", resp.pcBlacklistService_list, " !=\n", resp_manual.pcBlacklistService_list); }
+
+if (log2str(resp_vt.pcBlacklistService_list)==log2str(resp_manual.pcBlacklistService_list))
+{ setverdict(pass); } else { setverdict(fail, "at line ", __LINE__, "\n", resp_vt.pcBlacklistService_list, " !=\n", resp_manual.pcBlacklistService_list); }
+
+} // testcase
+
+control {
+ execute(tc_sapc());
+}
+
+}
+with {
+ encode "XML"
+}
diff --git a/Regression_Test_java/src/all_from/types.ttcn b/Regression_Test_java/src/all_from/types.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..42e7598d8d92e17dbbdadb1de9125cd68a33d070
--- /dev/null
+++ b/Regression_Test_java/src/all_from/types.ttcn
@@ -0,0 +1,136 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ * Szabo, Bence Janos
+ *
+ ******************************************************************************/
+module types {
+// Types are kept separate to cut down on the size of the generated code
+// from the actual test (all_from*.ttcn, sapc.ttcn)
+
+type component A {
+ var RoI v_roi:={20,21,22};
+ var SoI v_soi:={20,21,22};
+}
+
+type record of integer RoI;
+type set of integer SoI;
+type record of float RoF;
+type record of SoI RoSoI;
+type record of RoI RoRoI;
+type record of RoOS RoRoOS;
+type record of SoOS RoSoOS;
+
+type set of integer MySetOfType (0 .. 10);
+
+type record of bitstring RoBS;
+
+type record of hexstring RoHS;
+
+type record of charstring RoCS;
+type set of charstring CoCS;
+
+type record of octetstring RoOS;
+type set of octetstring SoOS;
+
+type record of universal charstring RoUCS;
+
+type record MyRecord {
+ integer i optional,
+ RoI roi optional,
+ SoI soi optional
+}
+
+type union MyUnion {
+ integer i,
+ RoI roi,
+ SoI soi
+}
+
+type record of MyRecord RoMyRec;
+type record of MyUnion RoMyUnion;
+
+type integer IntArray[3..8];
+
+//==== Function Reference ====
+//this is just a dummy type to test all from for function references
+type function F_int2int(in integer pl_i) return integer;
+
+type record of F_int2int RoF_int2int;
+
+/* * * * * * * * sapc types * * * * * * * */
+
+type record CreateSAPCSubscription
+{
+ record of charstring pcBlacklistService_list
+};
+
+type record GetResponseSAPCSubscription
+{
+ record of charstring pcBlacklistService_list
+};
+
+/*
+type record MOD {
+ GetResponseSAPCSubscription getResponseSAPCSubscription
+}
+
+type record MOA {
+ MOD getMODefinition
+}
+
+type record GetResp {
+ MOA mOAttributes
+}
+
+type record CAI3gCommand {
+ GetResp getResponse
+}
+*/
+
+/* * * * Subtypes * * * */
+
+type integer PosInt (0..infinity);
+
+type float NegFloat (-infinity..0.0);
+
+type bitstring ByteString length (8);
+
+type hexstring WordString length (4);
+
+type octetstring DWordString length (4);
+
+type charstring TtcnFileName (pattern "*.ttcn");
+
+type universal charstring XsdString (
+ char(0,0,0,9)..char(0,0,0,9),
+ char(0,0,0,10)..char(0,0,0,10),
+ char(0,0,0,12)..char(0,0,0,12),
+ char(0,0,0,32)..char(0,0,215,255),
+ char(0,0,224,0)..char(0,0,255,253),
+ char(0,1,0,0)..char(0,16,255,253)
+);
+
+type record length (0..3) of integer ShortRoI;
+
+type record length (0..3) of float ShortRoF;
+
+type record length (0..3) of bitstring ShortRoBS;
+
+type record length (0..3) of hexstring ShortRoHS;
+
+type record length (0..3) of octetstring ShortRoOS;
+
+type record length (0..3) of charstring ShortRoCS;
+
+type record length (0..3) of universal charstring ShortRoUCS;
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/bit_to_OK.ttcn b/Regression_Test_java/src/predefFunctions/bit_to_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..417a99353db6f1a432dd906fbfddcc5e051707b7
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/bit_to_OK.ttcn
@@ -0,0 +1,289 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module bit_to_OK {
+
+type component PDTestComponent {};
+
+/*--- BIT2HEX --------------------------------------------------*/
+
+modulepar hexstring b2hpar := bit2hex(''B)
+modulepar hexstring b2hpar1 := bit2hex('000000000000'B & ''B & '111111111111'B)
+modulepar hexstring b2hpar2 := bit2hex(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12))
+modulepar hexstring b2hpar3 := bit2hex(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13))
+modulepar hexstring b2hpar4 := bit2hex((not4b '111111111111'B) & '111111111111'B)
+modulepar hexstring b2hpar5 := bit2hex('000000000000111111111111'B and4b '000000000000111111111111'B)
+modulepar hexstring b2hpar6 := bit2hex('000000000000000000000000'B or4b '000000000000111111111111'B)
+modulepar hexstring b2hpar7 := bit2hex('000000000000000000000000'B xor4b '000000000000111111111111'B)
+modulepar hexstring b2hpar8 := bit2hex('10011'B)
+modulepar hexstring b2hpar9 := bit2hex('11'B)
+
+modulepar hexstring b2hparh := '000FFF'H
+
+testcase bit_to_hex() runs on PDTestComponent{
+
+ if ((b2hpar == bit2hex(''B))
+ and (b2hpar == ''H))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2hpar1 == bit2hex('000000000000'B & ''B & '111111111111'B))
+ and (b2hpar1 == b2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2hpar2 == bit2hex(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12)))
+ and (b2hpar2 == b2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2hpar3 == bit2hex(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13)))
+ and (b2hpar3 == b2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2hpar4 == bit2hex((not4b '111111111111'B) & '111111111111'B))
+ and (b2hpar4 == b2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2hpar5 == bit2hex('000000000000111111111111'B and4b '000000000000111111111111'B))
+ and (b2hpar5 == b2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2hpar6 == bit2hex('000000000000000000000000'B or4b '000000000000111111111111'B))
+ and (b2hpar6 == b2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2hpar7 == bit2hex('000000000000000000000000'B xor4b '000000000000111111111111'B))
+ and (b2hpar7 == b2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2hpar8 == bit2hex('10011'B))
+ and (b2hpar8 == '13'H))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2hpar9 == bit2hex('11'B))
+ and (b2hpar9 == '3'H))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+
+}
+
+/*--- BIT2INT --------------------------------------------------*/
+
+modulepar integer b2ipar := bit2int(''B)
+modulepar integer b2ipar1 := bit2int('111111'B & '111111'B)
+modulepar integer b2ipar2 := bit2int((not4b '111111'B) & '111111'B)
+modulepar integer b2ipar3 := bit2int(('111111'B and4b '000000'B) & '111111'B)
+modulepar integer b2ipar4 := bit2int(('000000'B or4b '000000'B) & '111111'B)
+modulepar integer b2ipar5 := bit2int(('000011'B xor4b '000011'B) & '111111'B)
+modulepar integer b2i1_16 := 12345678910111213141516;
+
+testcase bit_to_int() runs on PDTestComponent{
+ var integer i1 := 12345678910111213141516;
+ var bitstring bs1 := '00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B;
+ var integer b;
+
+ if ((b2ipar == bit2int(''B))
+ and (b2ipar == 0))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2ipar1 == bit2int('111111'B & '111111'B))
+ and (b2ipar1 == 4095))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ b := bit2int((not4b '111111'B) & '111111'B)
+ if ((b2ipar2 == b)
+ and (b2ipar2 == 63))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ b := bit2int(('111111'B and4b '000000'B) & '111111'B)
+ if ((b2ipar3 == b)
+ and (b2ipar3 == 63))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ b := bit2int(('000000'B or4b '000000'B) & '111111'B)
+ if ((b2ipar4 == b)
+ and (b2ipar4 == 63))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ b := bit2int(('000011'B xor4b '000011'B) & '111111'B)
+ if ((b2ipar5 == b)
+ and (b2ipar5 == 63))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if (bit2int(bs1) == 12345678910111213141516)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (bit2int('00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B) == b2i1_16)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (bit2int(bs1) == 12345678910111213141516)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (bit2int(int2bit(bit2int('010100111010100001010110110010101101000100100110010100010111011111000001100'B), 75)) == b2i1_16)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ var integer j
+ for (j:=0; j<1024; j:=j+1) {
+ if (bit2int(int2bit(j,10)) == j)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+}
+
+/*--- BIT2OCT --------------------------------------------------*/
+
+modulepar octetstring b2opar := bit2oct(''B)
+modulepar octetstring b2opar1 := bit2oct('000000000000'B & ''B & '111111111111'B)
+modulepar octetstring b2opar2 := bit2oct(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12))
+modulepar octetstring b2opar3 := bit2oct(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13))
+modulepar octetstring b2opar4 := bit2oct((not4b '111111111111'B) & '111111111111'B)
+modulepar octetstring b2opar5 := bit2oct('000000000000111111111111'B and4b '000000000000111111111111'B)
+modulepar octetstring b2opar6 := bit2oct('000000000000000000000000'B or4b '000000000000111111111111'B)
+modulepar octetstring b2opar7 := bit2oct('000000000000000000000000'B xor4b '000000000000111111111111'B)
+modulepar octetstring b2opar8 := bit2oct('10011'B)
+modulepar octetstring b2opar9 := bit2oct('11'B)
+
+modulepar octetstring b2oparo := '000FFF'O
+
+testcase bit_to_oct() runs on PDTestComponent{
+
+ if ((b2opar == bit2oct(''B))
+ and (b2opar == ''O))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2opar1 == bit2oct('000000000000'B & ''B & '111111111111'B))
+ and (b2opar1 == b2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2opar2 == bit2oct(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12)))
+ and (b2opar2 == b2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2opar3 == bit2oct(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13)))
+ and (b2opar3 == b2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2opar4 == bit2oct((not4b '111111111111'B) & '111111111111'B))
+ and (b2opar4 == b2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2opar5 == bit2oct('000000000000111111111111'B and4b '000000000000111111111111'B))
+ and (b2opar5 == b2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2opar6 == bit2oct('000000000000000000000000'B or4b '000000000000111111111111'B))
+ and (b2opar6 == b2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2opar7 == bit2oct('000000000000000000000000'B xor4b '000000000000111111111111'B))
+ and (b2opar7 == b2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2opar8 == bit2oct('10011'B))
+ and (b2opar8 == '13'O))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2opar9 == bit2oct('11'B))
+ and (b2opar9 == '03'O))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+/*--- BIT2STR --------------------------------------------------*/
+
+modulepar charstring b2spar := bit2str(''B)
+modulepar charstring b2spar1 := bit2str('000000'B & ''B & '111111'B)
+modulepar charstring b2spar2 := bit2str(substr('000000111111'B,0,6) & ''B & substr('000000111111'B,6,6))
+modulepar charstring b2spar3 := bit2str(('000000'B <@ 3) & ''B & ('111111'B @> 3))
+modulepar charstring b2spar4 := bit2str((not4b '111111'B) & '111111'B)
+modulepar charstring b2spar5 := bit2str('000000111111'B and4b '000000111111'B)
+modulepar charstring b2spar6 := bit2str('000000000000'B or4b '000000111111'B)
+modulepar charstring b2spar7 := bit2str('000000000000'B xor4b '000000111111'B)
+
+modulepar charstring b2spars := "000000111111"
+
+testcase bit_to_str() runs on PDTestComponent{
+
+ if ((b2spar == bit2str(''B))
+ and (b2spar == ""))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2spar1 == bit2str('000000'B & ''B & '111111'B))
+ and (b2spar1 == b2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2spar2 == bit2str(substr('000000111111'B,0,6) & ''B & substr('000000111111'B,6,6)))
+ and (b2spar2 == b2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2spar3 == bit2str(('000000'B <@ 3) & ''B & ('111111'B @> 3)))
+ and (b2spar3 == b2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2spar4 == bit2str((not4b '111111'B) & '111111'B))
+ and (b2spar4 == b2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2spar5 == bit2str('000000111111'B and4b '000000111111'B))
+ and (b2spar5 == b2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2spar6 == bit2str('000000000000'B or4b '000000111111'B))
+ and (b2spar6 == b2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((b2spar7 == bit2str('000000000000'B xor4b '000000111111'B))
+ and (b2spar7 == b2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+control {
+ execute (bit_to_hex());
+ execute (bit_to_int());
+ execute (bit_to_oct());
+ execute (bit_to_str());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/bit_to_SW.ttcn b/Regression_Test_java/src/predefFunctions/bit_to_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..db6a1f4c3641a63eaf382e4510ec31fe3c0d881d
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/bit_to_SW.ttcn
@@ -0,0 +1,311 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module bit_to_SW { //^In TTCN-3 module `bit_to_SW'://
+
+type component PDTestComponent {};
+
+/*--- BIT2HEX --------------------------------------------------*/
+
+const hexstring b2hcon := bit2hex(''B)
+const hexstring b2hcon1 := bit2hex('000000000000'B & ''B & '111111111111'B)
+const hexstring b2hcon2 := bit2hex(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12))
+const hexstring b2hcon3 := bit2hex(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13))
+const hexstring b2hcon4 := bit2hex((not4b '111111111111'B) & '111111111111'B)
+const hexstring b2hcon5 := bit2hex('000000000000111111111111'B and4b '000000000000111111111111'B)
+const hexstring b2hcon6 := bit2hex('000000000000000000000000'B or4b '000000000000111111111111'B)
+const hexstring b2hcon7 := bit2hex('000000000000000000000000'B xor4b '000000000000111111111111'B)
+const hexstring b2hcon8 := bit2hex('10011'B)
+const hexstring b2hcon9 := bit2hex('11'B)
+
+const hexstring b2hconh := '000FFF'H
+
+testcase bit_to_hex() runs on PDTestComponent{ //^In testcase definition//
+
+ if ((b2hcon == bit2hex(''B))
+ and (b2hcon == ''H))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2hcon1 == bit2hex('000000000000'B & ''B & '111111111111'B))
+ and (b2hcon1 == b2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2hcon2 == bit2hex(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12)))
+ and (b2hcon2 == b2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2hcon3 == bit2hex(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13)))
+ and (b2hcon3 == b2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2hcon4 == bit2hex((not4b '111111111111'B) & '111111111111'B))
+ and (b2hcon4 == b2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2hcon5 == bit2hex('000000000000111111111111'B and4b '000000000000111111111111'B))
+ and (b2hcon5 == b2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2hcon6 == bit2hex('000000000000000000000000'B or4b '000000000000111111111111'B))
+ and (b2hcon6 == b2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2hcon7 == bit2hex('000000000000000000000000'B xor4b '000000000000111111111111'B))
+ and (b2hcon7 == b2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2hcon8 == bit2hex('10011'B))
+ and (b2hcon8 == '13'H))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2hcon9 == bit2hex('11'B))
+ and (b2hcon9 == '3'H))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- BIT2INT --------------------------------------------------*/
+
+const integer b2icon := bit2int(''B)
+const integer b2icon1 := bit2int('111111'B & '111111'B)
+const integer b2icon2 := bit2int((not4b '111111'B) & '111111'B)
+const integer b2icon3 := bit2int(('111111'B and4b '000000'B) & '111111'B)
+const integer b2icon4 := bit2int(('000000'B or4b '000000'B) & '111111'B)
+const integer b2icon5 := bit2int(('000011'B xor4b '000011'B) & '111111'B)
+const integer i1 := 12345678910111213141516;
+const bitstring bs1 := '00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B;
+
+testcase bit_to_int() runs on PDTestComponent{ //^In testcase definition//
+
+ if ((b2icon == bit2int(''B))
+ and (b2icon == 0))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2icon1 == bit2int('111111'B & '111111'B))
+ and (b2icon1 == 4095))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2icon2 == bit2int((not4b '111111'B) & '111111'B))
+ and (b2icon2 == 63))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2icon3 == bit2int(('111111'B and4b '000000'B) & '111111'B))
+ and (b2icon3 == 63))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2icon4 == bit2int(('000000'B or4b '000000'B) & '111111'B))
+ and (b2icon4 == 63))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2icon5 == bit2int(('000011'B xor4b '000011'B) & '111111'B))
+ and (b2icon5 == 63))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if (bit2int(bs1) == 12345678910111213141516)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if (bit2int('00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B) == 12345678910111213141516)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if (bit2int(bs1) == 12345678910111213141516)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if (bit2int(int2bit(bit2int('010100111010100001010110110010101101000100100110010100010111011111000001100'B), 75)) == 12345678910111213141516)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- BIT2OCT --------------------------------------------------*/
+
+const octetstring b2ocon := bit2oct(''B)
+const octetstring b2ocon1 := bit2oct('000000000000'B & ''B & '111111111111'B)
+const octetstring b2ocon2 := bit2oct(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12))
+const octetstring b2ocon3 := bit2oct(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13))
+const octetstring b2ocon4 := bit2oct((not4b '111111111111'B) & '111111111111'B)
+const octetstring b2ocon5 := bit2oct('000000000000111111111111'B and4b '000000000000111111111111'B)
+const octetstring b2ocon6 := bit2oct('000000000000000000000000'B or4b '000000000000111111111111'B)
+const octetstring b2ocon7 := bit2oct('000000000000000000000000'B xor4b '000000000000111111111111'B)
+const octetstring b2ocon8 := bit2oct('10011'B)
+const octetstring b2ocon9 := bit2oct('11'B)
+
+const octetstring b2ocono := '000FFF'O
+
+testcase bit_to_oct() runs on PDTestComponent{ //^In testcase definition//
+
+ if ((b2ocon == bit2oct(''B))
+ and (b2ocon == ''O))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2ocon1 == bit2oct('000000000000'B & ''B & '111111111111'B))
+ and (b2ocon1 == b2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2ocon2 == bit2oct(substr('000000000000111111111111'B,0,12) & ''B & substr('000000000000111111111111'B,12,12)))
+ and (b2ocon2 == b2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2ocon3 == bit2oct(('000000000000'B <@ 13) & ''B & ('111111111111'B @> 13)))
+ and (b2ocon3 == b2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2ocon4 == bit2oct((not4b '111111111111'B) & '111111111111'B))
+ and (b2ocon4 == b2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2ocon5 == bit2oct('000000000000111111111111'B and4b '000000000000111111111111'B))
+ and (b2ocon5 == b2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2ocon6 == bit2oct('000000000000000000000000'B or4b '000000000000111111111111'B))
+ and (b2ocon6 == b2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2ocon7 == bit2oct('000000000000000000000000'B xor4b '000000000000111111111111'B))
+ and (b2ocon7 == b2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2ocon8 == bit2oct('10011'B))
+ and (b2ocon8 == '13'O))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2ocon9 == bit2oct('11'B))
+ and (b2ocon9 == '03'O))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- BIT2STR --------------------------------------------------*/
+
+const charstring b2scon := bit2str(''B)
+const charstring b2scon1 := bit2str('000000'B & ''B & '111111'B)
+const charstring b2scon2 := bit2str(substr('000000111111'B,0,6) & ''B & substr('000000111111'B,6,6))
+const charstring b2scon3 := bit2str(('000000'B <@ 3) & ''B & ('111111'B @> 3))
+const charstring b2scon4 := bit2str((not4b '111111'B) & '111111'B)
+const charstring b2scon5 := bit2str('000000111111'B and4b '000000111111'B)
+const charstring b2scon6 := bit2str('000000000000'B or4b '000000111111'B)
+const charstring b2scon7 := bit2str('000000000000'B xor4b '000000111111'B)
+
+const charstring b2scons := "000000111111"
+
+testcase bit_to_str() runs on PDTestComponent{ //^In testcase definition//
+
+ if ((b2scon == bit2str(''B))
+ and (b2scon == ""))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2scon1 == bit2str('000000'B & ''B & '111111'B))
+ and (b2scon1 == b2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2scon2 == bit2str(substr('000000111111'B,0,6) & ''B & substr('000000111111'B,6,6)))
+ and (b2scon2 == b2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2scon3 == bit2str(('000000'B <@ 3) & ''B & ('111111'B @> 3)))
+ and (b2scon3 == b2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2scon4 == bit2str((not4b '111111'B) & '111111'B))
+ and (b2scon4 == b2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2scon5 == bit2str('000000111111'B and4b '000000111111'B))
+ and (b2scon5 == b2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2scon6 == bit2str('000000000000'B or4b '000000111111'B))
+ and (b2scon6 == b2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((b2scon7 == bit2str('000000000000'B xor4b '000000111111'B))
+ and (b2scon7 == b2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+control {
+ execute (bit_to_hex());
+ execute (bit_to_int());
+ execute (bit_to_oct());
+ execute (bit_to_str());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/char_to_OK.ttcn b/Regression_Test_java/src/predefFunctions/char_to_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..b01361e285e2c6369d1d8e716552353d7a2ced1a
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/char_to_OK.ttcn
@@ -0,0 +1,156 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module char_to_OK {
+
+type component PDTestComponent {};
+
+/*--- CHAR2INT --------------------------------------------------*/
+
+const charstring c2ipars := "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+modulepar integer c2ipar1 := char2int("A")
+modulepar integer c2ipar2 := char2int("\n")
+modulepar integer c2ipar3 := char2int("" & "A" & "")
+modulepar integer c2ipar4 := char2int(substr(c2ipars,0,1))
+modulepar integer c2ipar5 := char2int("A" <@ 1)
+
+
+testcase char_to_int() runs on PDTestComponent{
+
+ if ((c2ipar1 == 65)
+ and (c2ipar1 == char2int("A")))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2ipar2 == 10)
+ and (c2ipar2 == char2int("\n")))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2ipar3 == 65)
+ and (c2ipar3 == char2int("" & "A" & "")))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2ipar4 == 65)
+ and (c2ipar4 == char2int(substr(c2ipars,0,1))))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2ipar5 == 65)
+ and (c2ipar5 == char2int("A" @> 1)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ var integer j
+ for (j:=0; j<lengthof(c2ipars); j:=j+1) {
+ if (char2int(substr(c2ipars,j,1))-char2int("A") == j)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+}
+
+/*--- UNICHAR2INT --------------------------------------------------*/
+
+const universal charstring uc2ipars := char(0,0,0,65) & "BCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+modulepar integer uc2ipar1 := unichar2int("A")
+modulepar integer uc2ipar2 := unichar2int(char(0,0,0,65))
+modulepar integer uc2ipar3 := unichar2int("" & char(0,0,0,65) & "")
+modulepar integer uc2ipar4 := unichar2int(substr(uc2ipars,0,1))
+modulepar integer uc2ipar5 := unichar2int(char(0,0,0,255))
+modulepar integer uc2ipar6 := unichar2int(char(0,0,255,255))
+modulepar integer uc2ipar7 := unichar2int(char(0,255,255,255))
+modulepar integer uc2ipar8 := unichar2int(char(127,255,255,255))
+
+
+testcase unichar_to_int() runs on PDTestComponent{
+
+ if ((uc2ipar1 == 65)
+ and (uc2ipar1 == unichar2int("A")))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((uc2ipar2 == 65)
+ and (uc2ipar2 == unichar2int(char(0,0,0,65))))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((uc2ipar3 == 65)
+ and (uc2ipar3 == unichar2int("" & char(0,0,0,65) & "")))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((uc2ipar4 == 65)
+ and (uc2ipar4 == unichar2int(substr(uc2ipars,0,1))))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((uc2ipar5 == 255)
+ and (uc2ipar5 == unichar2int(char(0,0,0,255))))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((uc2ipar6 == 65535)
+ and (uc2ipar6 == unichar2int(char(0,0,255,255))))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((uc2ipar7 == 16777215)
+ and (uc2ipar7 == unichar2int(char(0,255,255,255))))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((uc2ipar8 == 2147483647)
+ and (uc2ipar8 == unichar2int(char(127,255,255,255))))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+/*--- CHAR2OCT --------------------------------------------------*/
+
+const charstring c2opars := "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+modulepar octetstring c2opar1 := char2oct("A")
+modulepar octetstring c2opar2 := char2oct("\n")
+modulepar octetstring c2opar3 := char2oct("" & "A" & "")
+modulepar octetstring c2opar4 := char2oct(substr(c2opars,0,1))
+modulepar octetstring c2opar5 := char2oct("A" @> 1)
+
+testcase char_to_oct() runs on PDTestComponent{
+
+ if ((c2opar1 == '41'O)
+ and (c2opar1 == char2oct("A")))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2opar2 == '0A'O)
+ and (c2opar2 == char2oct("\n")))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2opar3 == '41'O)
+ and (c2opar3 == char2oct("" & "A" & "")))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2opar4 == '41'O)
+ and (c2opar4 == char2oct(substr(c2ipars,0,1))))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2opar5 == '41'O)
+ and (c2opar5 == char2oct("A" @> 1)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ var integer j
+ for (j:=0; j<lengthof(c2opars); j:=j+1) {
+ if (oct2int(char2oct(substr(c2opars,j,1)))-65 == j)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+}
+
+control {
+ execute (char_to_int());
+ execute (unichar_to_int());
+ execute (char_to_oct());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/char_to_SW.ttcn b/Regression_Test_java/src/predefFunctions/char_to_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..2b6fc190eeef26765a43fab5102f47727871b5d9
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/char_to_SW.ttcn
@@ -0,0 +1,160 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module char_to_SW { //^In TTCN-3 module `char_to_SW'://
+
+type component PDTestComponent {};
+
+/*--- CHAR2INT --------------------------------------------------*/
+
+const charstring c2icons := "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+const integer c2icon1 := char2int("A")
+const integer c2icon2 := char2int("\n")
+const integer c2icon3 := char2int("" & "A" & "")
+const integer c2icon4 := char2int(substr(c2icons,0,1))
+const integer c2icon5 := char2int("A" <@ 1)
+
+
+testcase char_to_int() runs on PDTestComponent{ //^In testcase definition//
+
+ if ((c2icon1 == 65)
+ and (c2icon1 == char2int("A")))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((c2icon2 == 10)
+ and (c2icon2 == char2int("\n")))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((c2icon3 == 65)
+ and (c2icon3 == char2int("" & "A" & "")))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((c2icon4 == 65)
+ and (c2icon4 == char2int(substr(c2icons,0,1))))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((c2icon5 == 65)
+ and (c2icon5 == char2int("A" @> 1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- UNICHAR2INT --------------------------------------------------*/
+
+const universal charstring uc2icons := char(0,0,0,65) & "BCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+const integer uc2icon1 := unichar2int("A")
+const integer uc2icon2 := unichar2int(char(0,0,0,65))
+const integer uc2icon3 := unichar2int("" & char(0,0,0,65) & "")
+const integer uc2icon4 := unichar2int(substr(uc2icons,0,1))
+const integer uc2icon5 := unichar2int(char(0,0,0,255))
+const integer uc2icon6 := unichar2int(char(0,0,255,255))
+const integer uc2icon7 := unichar2int(char(0,255,255,255))
+const integer uc2icon8 := unichar2int(char(127,255,255,255))
+
+
+testcase unichar_to_int() runs on PDTestComponent{ //^In testcase definition//
+
+ if ((uc2icon1 == 65)
+ and (uc2icon1 == unichar2int("A")))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((uc2icon2 == 65)
+ and (uc2icon2 == unichar2int(char(0,0,0,65))))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((uc2icon3 == 65)
+ and (uc2icon3 == unichar2int("" & char(0,0,0,65) & "")))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((uc2icon4 == 65)
+ and (uc2icon4 == unichar2int(substr(uc2icons,0,1))))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((uc2icon5 == 255)
+ and (uc2icon5 == unichar2int(char(0,0,0,255))))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((uc2icon6 == 65535)
+ and (uc2icon6 == unichar2int(char(0,0,255,255))))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((uc2icon7 == 16777215)
+ and (uc2icon7 == unichar2int(char(0,255,255,255))))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((uc2icon8 == 2147483647)
+ and (uc2icon8 == unichar2int(char(127,255,255,255))))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- CHAR2OCT --------------------------------------------------*/
+
+const charstring c2ocons := "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+
+const octetstring c2ocon1 := char2oct("A")
+const octetstring c2ocon2 := char2oct("\n")
+const octetstring c2ocon3 := char2oct("" & "A" & "")
+const octetstring c2ocon4 := char2oct(substr(c2ocons,0,1))
+const octetstring c2ocon5 := char2oct("A" @> 1)
+
+testcase char_to_oct() runs on PDTestComponent{ //^In testcase definition//
+
+ if ((c2ocon1 == '41'O)
+ and (c2ocon1 == char2oct("A")))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((c2ocon2 == '0A'O)
+ and (c2ocon2 == char2oct("\n")))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((c2ocon3 == '41'O)
+ and (c2ocon3 == char2oct("" & "A" & "")))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((c2ocon4 == '41'O)
+ and (c2ocon4 == char2oct(substr(c2icons,0,1))))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((c2ocon5 == '41'O)
+ and (c2ocon5 == char2oct("A" @> 1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+control {
+ execute (char_to_int());
+ execute (unichar_to_int());
+ execute (char_to_oct());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/enum_to_OK.ttcn b/Regression_Test_java/src/predefFunctions/enum_to_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..6f614ad190df3123f8f898ccfa303cc9ca63154a
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/enum_to_OK.ttcn
@@ -0,0 +1,97 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module enum_to_OK { //^In TTCN-3 module `enum_to_OK'://
+
+type component PDTestComponent {};
+
+/*--- ENUM2INT --------------------------------------------------*/
+
+type enumerated MyFirstEnumType { Monday, Tuesday, Wednesday, Thursday, Friday };
+type enumerated MySecondEnumType { Saturday, Sunday, Monday };
+type enumerated MyThirdEnumType { first(-3), second (0), third };
+
+
+testcase enum_to_int() runs on PDTestComponent{ //In testcase definition//
+
+ const MyFirstEnumType enumvar1_1 := Monday;
+ const MyFirstEnumType enumvar1_2 := Wednesday;
+ const MyFirstEnumType enumvar1_3 := Friday;
+
+ const MySecondEnumType enumvar2_1 := Monday;
+ const MySecondEnumType enumvar2_2 := Saturday;
+ const MySecondEnumType enumvar2_3 := Sunday;
+
+ const MyThirdEnumType enumvar3_1 := third;
+ const MyThirdEnumType enumvar3_2 := first;
+ const MyThirdEnumType enumvar3_3 := second;
+
+
+ const integer e2ivar1_1 := enum2int(enumvar1_1); // returns 0
+ const integer e2ivar1_2 := enum2int(enumvar1_2); // returns 2
+ const integer e2ivar1_3 := enum2int(enumvar1_3); // returns 4
+
+ const integer e2ivar2_1 := enum2int(enumvar2_1); // returns 2
+ const integer e2ivar2_2 := enum2int(enumvar2_2); // returns 0
+ const integer e2ivar2_3 := enum2int(enumvar2_3); // returns 1
+
+ const integer e2ivar3_1 := enum2int(enumvar3_1); // returns 1
+ const integer e2ivar3_2 := enum2int(enumvar3_2); // returns -3
+ const integer e2ivar3_3 := enum2int(enumvar3_3); // returns 0
+
+
+ if ((e2ivar1_1 == 0)
+ and (e2ivar1_1 == enum2int(enumvar1_1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //In else statement// //Control never reaches this code because of previous effective condition\(s\)//
+ if ((e2ivar1_2 == 2)
+ and (e2ivar1_2 == enum2int(enumvar1_2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //In else statement// //Control never reaches this code because of previous effective condition\(s\)//
+ if ((e2ivar1_3 == 4)
+ and (e2ivar1_3 == enum2int(enumvar1_3)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //In else statement// //Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((e2ivar2_1 == 2)
+ and (e2ivar2_1 == enum2int(enumvar2_1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //In else statement// //Control never reaches this code because of previous effective condition\(s\)//
+ if ((e2ivar2_2 == 0)
+ and (e2ivar2_2 == enum2int(enumvar2_2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //In else statement// //Control never reaches this code because of previous effective condition\(s\)//
+ if ((e2ivar2_3 == 1)
+ and (e2ivar2_3 == enum2int(enumvar2_3)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //In else statement// //Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((e2ivar3_1 == 1)
+ and (e2ivar3_1 == enum2int(enumvar3_1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //In else statement// //Control never reaches this code because of previous effective condition\(s\)//
+ if ((e2ivar3_2 == -3)
+ and (e2ivar3_2 == enum2int(enumvar3_2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //In else statement// //Control never reaches this code because of previous effective condition\(s\)//
+ if ((e2ivar3_3 == 0)
+ and (e2ivar3_3 == enum2int(enumvar3_3)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //In else statement// //Control never reaches this code because of previous effective condition\(s\)//
+
+}
+
+control {
+ execute (enum_to_int());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/enum_to_SW.ttcn b/Regression_Test_java/src/predefFunctions/enum_to_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..6e21224fc23a09f578ab8b415602ae87850ab9ed
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/enum_to_SW.ttcn
@@ -0,0 +1,106 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module enum_to_SW { //^In TTCN-3 module `enum_to_SW'://
+
+type component PDTestComponent {};
+
+/*--- ENUM2INT --------------------------------------------------*/
+
+type enumerated MyFirstEnumType { Monday, Tuesday, Wednesday, Thursday, Friday };
+type enumerated MySecondEnumType { Saturday, Sunday, Monday };
+type enumerated MyThirdEnumType { first(-3), second (0), third };
+
+
+testcase enum_to_int() runs on PDTestComponent{ //^In testcase definition//
+
+ const MyFirstEnumType enumvar1_1 := Monday;
+ const MyFirstEnumType enumvar1_2 := Wednesday;
+ const MyFirstEnumType enumvar1_3 := Friday;
+
+ const MySecondEnumType enumvar2_1 := Monday;
+ const MySecondEnumType enumvar2_2 := Saturday;
+ const MySecondEnumType enumvar2_3 := Sunday;
+
+ const MyThirdEnumType enumvar3_1 := third;
+ const MyThirdEnumType enumvar3_2 := first;
+ const MyThirdEnumType enumvar3_3 := second;
+
+
+ const integer e2ivar1_1 := enum2int(enumvar1_1); // returns 0
+ const integer e2ivar1_2 := enum2int(enumvar1_2); // returns 2
+ const integer e2ivar1_3 := enum2int(enumvar1_3); // returns 4
+
+ const integer e2ivar2_1 := enum2int(enumvar2_1); // returns 2
+ const integer e2ivar2_2 := enum2int(enumvar2_2); // returns 0
+ const integer e2ivar2_3 := enum2int(enumvar2_3); // returns 1
+
+ const integer e2ivar3_1 := enum2int(enumvar3_1); // returns 1
+ const integer e2ivar3_2 := enum2int(enumvar3_2); // returns -3
+ const integer e2ivar3_3 := enum2int(enumvar3_3); // returns 0
+
+
+ if ((e2ivar1_1 == 0)
+ and (e2ivar1_1 == enum2int(enumvar1_1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((e2ivar1_2 == 2)
+ and (e2ivar1_2 == enum2int(enumvar1_2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((e2ivar1_3 == 4)
+ and (e2ivar1_3 == enum2int(enumvar1_3)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((e2ivar2_1 == 2)
+ and (e2ivar2_1 == enum2int(enumvar2_1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((e2ivar2_2 == 0)
+ and (e2ivar2_2 == enum2int(enumvar2_2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((e2ivar2_3 == 1)
+ and (e2ivar2_3 == enum2int(enumvar2_3)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((e2ivar3_1 == 1)
+ and (e2ivar3_1 == enum2int(enumvar3_1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((e2ivar3_2 == -3)
+ and (e2ivar3_2 == enum2int(enumvar3_2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+ if ((e2ivar3_3 == 0)
+ and (e2ivar3_3 == enum2int(enumvar3_3)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning: Control never reaches this code because of previous effective condition\(s\)//
+
+}
+
+control {
+ execute (enum_to_int());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/float_to_OK.ttcn b/Regression_Test_java/src/predefFunctions/float_to_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..ced20f1b185c1eb6f9599fd8fc59f6a3b770b442
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/float_to_OK.ttcn
@@ -0,0 +1,142 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module float_to_OK {
+
+type component PDTestComponent {};
+
+/*--- FLOAT2INT --------------------------------------------------*/
+
+
+modulepar integer f2ipar1 := float2int(5E-1)
+modulepar integer f2ipar2 := float2int(0.345)
+modulepar integer f2ipar3 := float2int(-0.345)
+modulepar integer f2ipar4 := float2int(-5E0)
+modulepar integer f2ipar5 := float2int(12345678910000.0)
+modulepar integer f2ipar6 := float2int(12345678910e+4)
+modulepar integer f2ipar7 := float2int(4294967296.0)
+
+testcase float_to_int() runs on PDTestComponent{
+
+ if ((f2ipar1 == 0)
+ and (f2ipar1 == float2int(5E-1)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2ipar2 == 0)
+ and (f2ipar2 == float2int(0.345)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2ipar3 == 0)
+ and (f2ipar3 == float2int(-0.345)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2ipar4 == -5)
+ and (f2ipar4 == float2int(-5E0)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ // Tests added for HL22929.
+ if ((f2ipar5 == 12345678910000)
+ and (f2ipar5 == float2int(12345678910000.0)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2ipar6 == 123456789100000)
+ and (f2ipar6 == float2int(12345678910e+4)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2ipar7 == 4294967296)
+ and (f2ipar7 == float2int(4294967296.0)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ var float f2ivar1 := 12345678910000.0
+ var float f2ivar2 := 12345678910e+4
+ var float f2ivar3 := 4294967296.0
+ if ((float2int(f2ivar1) == 12345678910000)
+ and (float2int(f2ivar1) == float2int(12345678910000.0)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((float2int(f2ivar2) == 123456789100000)
+ and (float2int(f2ivar2) == float2int(123456789100000.0)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((float2int(f2ivar3) == 4294967296)
+ and (float2int(f2ivar3) == float2int(4294967296.0)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+/*--- FLOAT2STR --------------------------------------------------*/
+
+modulepar charstring f2spar := "1234567890123456789012345678901234567890"
+
+modulepar charstring f2spar1 := float2str(5E-1)
+modulepar charstring f2spar2 := float2str(-5E-1)
+modulepar charstring f2spar3 := float2str(0.345)
+modulepar charstring f2spar4 := float2str(-0.345)
+modulepar charstring f2spar5 := float2str(0.1234567)
+modulepar charstring f2spar6 := float2str(123456748901.0)
+modulepar charstring f2spar7 := float2str(123456758901.0)
+modulepar charstring f2spar8 := float2str(infinity)
+modulepar charstring f2spar9 := float2str(-infinity)
+modulepar charstring f2spar10 := float2str(not_a_number)
+
+
+testcase float_to_str() runs on PDTestComponent{
+
+ if ((f2spar1 == "0.500000")
+ and (f2spar1 == float2str(5E-1)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2spar2 == "-0.500000")
+ and (f2spar2 == float2str(-5E-1)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2spar3 == "0.345000")
+ and (f2spar3 == float2str(0.345)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2spar4 == "-0.345000")
+ and (f2spar4 == float2str(-0.345)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2spar5 == "0.123457")
+ and (f2spar5 == float2str(0.1234567)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2spar6 == "1.234567e+11")
+ and (f2spar6 == float2str(123456748901.0)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2spar7 == "1.234568e+11")
+ and (f2spar7 == float2str(123456758901.0)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2spar8 == "infinity")
+ and (f2spar8 == float2str(infinity)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2spar9 == "-infinity")
+ and (f2spar9 == float2str(-infinity)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((f2spar10 == "not_a_number")
+ and (f2spar10 == float2str(not_a_number)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+control {
+ execute (float_to_int());
+ execute (float_to_str());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/float_to_SW.ttcn b/Regression_Test_java/src/predefFunctions/float_to_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..271d21f752a802fa29af3c83c2e789c4df568135
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/float_to_SW.ttcn
@@ -0,0 +1,143 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module float_to_SW { //^In TTCN-3 module `float_to_SW'://
+
+type component PDTestComponent {};
+
+/*--- FLOAT2INT --------------------------------------------------*/
+
+
+const integer f2icon1 := float2int(5E-1)
+const integer f2icon2 := float2int(0.345)
+const integer f2icon3 := float2int(-0.345)
+const integer f2icon4 := float2int(-5E0)
+const integer f2icon5 := float2int(12345678910000.0)
+const integer f2icon6 := float2int(12345678910e+4)
+const integer f2icon7 := float2int(4294967296.0)
+
+testcase float_to_int() runs on PDTestComponent{ //In testcase definition//
+
+ if ((f2icon1 == 0)
+ and (f2icon1 == float2int(5E-1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2icon2 == 0)
+ and (f2icon2 == float2int(0.345)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2icon3 == 0)
+ and (f2icon3 == float2int(-0.345)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2icon4 == -5)
+ and (f2icon4 == float2int(-5E0)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ // Tests added for HL22929.
+ if ((f2icon5 == 12345678910000)
+ and (f2icon5 == float2int(12345678910000.0)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2icon6 == 123456789100000)
+ and (f2icon6 == float2int(12345678910e+4)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2icon7 == 4294967296)
+ and (f2icon7 == float2int(4294967296.0)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- FLOAT2STR --------------------------------------------------*/
+
+const charstring f2scon := "1234567890123456789012345678901234567890"
+
+const charstring f2scon1 := float2str(5E-1)
+const charstring f2scon2 := float2str(-5E-1)
+const charstring f2scon3 := float2str(0.345)
+const charstring f2scon4 := float2str(-0.345)
+const charstring f2scon5 := float2str(0.1234567)
+const charstring f2scon6 := float2str(123456748901.0)
+const charstring f2scon7 := float2str(123456758901.0)
+const charstring f2scon8 := float2str(infinity);
+const charstring f2scon9 := float2str(-infinity);
+const charstring f2scon10 := float2str(not_a_number);
+
+
+testcase float_to_str() runs on PDTestComponent{ //In testcase definition//
+
+ if ((f2scon1 == "0.500000")
+ and (f2scon1 == float2str(5E-1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2scon2 == "-0.500000")
+ and (f2scon2 == float2str(-5E-1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2scon3 == "0.345000")
+ and (f2scon3 == float2str(0.345)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2scon4 == "-0.345000")
+ and (f2scon4 == float2str(-0.345)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2scon5 == "0.123457")
+ and (f2scon5 == float2str(0.1234567)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2scon6 == "1.234567e+11")
+ and (f2scon6 == float2str(123456748901.0)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2scon7 == "1.234568e+11")
+ and (f2scon7 == float2str(123456758901.0)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2scon8 == "infinity")
+ and (f2scon8 == float2str(infinity)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2scon9 == "-infinity")
+ and (f2scon9 == float2str(-infinity)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((f2scon10 == "not_a_number")
+ and (f2scon10 == float2str(not_a_number)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+control {
+ execute (float_to_int());
+ execute (float_to_str());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/hex_to_OK.ttcn b/Regression_Test_java/src/predefFunctions/hex_to_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..7a7abfd0806311ad8605230ae9ce30af00d4abb2
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/hex_to_OK.ttcn
@@ -0,0 +1,279 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module hex_to_OK {
+
+type component PDTestComponent {};
+
+/*--- HEX2BIT --------------------------------------------------*/
+
+modulepar bitstring h2bpar := hex2bit(''H)
+modulepar bitstring h2bpar1 := hex2bit('000000'H & ''H & '111111'H)
+modulepar bitstring h2bpar2 := hex2bit(substr('000000111111'H,0,6) & ''H & substr('000000111111'H,6,6))
+const bitstring h2bcon2 := hex2bit(substr('000000111111'H,0,6) & ''H & substr('000000111111'H,6,6))
+modulepar bitstring h2bpar3 := hex2bit(('000000'H <@ lengthof(h2bcon2)/2) & ''H & ('111111'H @> lengthof(h2bcon2)/2))
+modulepar bitstring h2bpar4 := hex2bit((not4b 'FFFFFF'H) & '111111'H)
+modulepar bitstring h2bpar5 := hex2bit('000000111111'H and4b '000000111111'H)
+modulepar bitstring h2bpar6 := hex2bit('000000000000'H or4b '000000111111'H)
+modulepar bitstring h2bpar7 := hex2bit('000000000000'H xor4b '000000111111'H)
+
+const bitstring h2bparb := '000000000000000000000000000100010001000100010001'B
+
+testcase hex_to_bit() runs on PDTestComponent{
+
+ if ((h2bpar == hex2bit(''H))
+ and (h2bpar == ''B))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2bpar1 == hex2bit('000000'H & ''H & '111111'H))
+ and (h2bpar1 == h2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2bpar2 == hex2bit(substr('000000111111'H,0,6) & ''H & substr('000000111111'H,6,6)))
+ and (h2bpar2 == h2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2bpar3 == hex2bit(('000000'H <@ lengthof(h2bpar2)/2) & ''H & ('111111'H @> lengthof(h2bpar2)/2)))
+ and (h2bpar3 == h2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2bpar4 == hex2bit((not4b 'FFFFFF'H) & '111111'H))
+ and (h2bpar4 == h2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2bpar5 == hex2bit('000000111111'H and4b '000000111111'H))
+ and (h2bpar5 == h2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2bpar6 == hex2bit('000000000000'H or4b '000000111111'H))
+ and (h2bpar6 == h2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2bpar7 == hex2bit('000000000000'H xor4b '000000111111'H))
+ and (h2bpar7 == h2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+/*--- HEX2INT --------------------------------------------------*/
+
+modulepar integer h2ipar := hex2int(''H)
+modulepar integer h2ipar1 := hex2int('FFF'H & 'FFFF'H)
+modulepar integer h2ipar2 := hex2int((not4b 'FFF'H) & 'FFFF'H)
+modulepar integer h2ipar3 := hex2int(('FFF'H and4b '000'H) & 'FFFF'H)
+modulepar integer h2ipar4 := hex2int(('000'H or4b '000'H) & 'FFFF'H)
+modulepar integer h2ipar5 := hex2int(('0FF'H xor4b '0FF'H) & 'FFFF'H)
+modulepar integer h2i1_16 := 12345678910111213141516;
+
+testcase hex_to_int() runs on PDTestComponent{
+ var integer i1 := 12345678910111213141516
+ var hexstring hs1 := '000000000000029D42B65689328BBE0C'H
+ var integer b;
+
+ if ((h2ipar == hex2int(''H))
+ and (h2ipar == 0))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2ipar1 == hex2int('FFF'H & 'FFFF'H))
+ and (h2ipar1 == 268435455))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ b := hex2int((not4b 'FFF'H) & 'FFFF'H)
+ if ((h2ipar2 == b)
+ and (h2ipar2 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ b := hex2int(('FFF'H and4b '000'H) & 'FFFF'H)
+ if ((h2ipar3 == b)
+ and (h2ipar3 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ b := hex2int(('000'H or4b '000'H) & 'FFFF'H)
+ if ((h2ipar4 == b)
+ and (h2ipar4 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ b := hex2int(('0FF'H xor4b '0FF'H) & 'FFFF'H)
+ if ((h2ipar5 == b)
+ and (h2ipar5 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if (hex2int(hs1) == i1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (hex2int('000000000000029D42B65689328BBE0C'H) == h2i1_16)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (hex2int(hs1) == 12345678910111213141516)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (hex2int('029D42B65689328BBE0C'H) == h2i1_16)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ var integer j
+ for (j:=0; j<4096; j:=j+1) {
+ if (hex2int(int2hex(j,3)) == j)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+}
+
+
+/*--- HEX2OCT --------------------------------------------------*/
+
+modulepar octetstring h2opar := hex2oct(''H)
+modulepar octetstring h2opar1 := hex2oct('000000'H & ''H & '111111'H)
+modulepar octetstring h2opar2 := hex2oct(substr('000000111111'H,0,6) & ''H & substr('000000111111'H,6,6))
+modulepar octetstring h2opar3 := hex2oct(('000000'H <@ 3) & ''H & ('111111'H @> 3))
+modulepar octetstring h2opar4 := hex2oct((not4b 'FFFFFF'H) & '111111'H)
+modulepar octetstring h2opar5 := hex2oct('000000111111'H and4b '000000111111'H)
+modulepar octetstring h2opar6 := hex2oct('000000000000'H or4b '000000111111'H)
+modulepar octetstring h2opar7 := hex2oct('000000000000'H xor4b '000000111111'H)
+modulepar octetstring h2opar8 := hex2oct('00011'H)
+modulepar octetstring h2opar9 := hex2oct('1'H)
+
+modulepar octetstring h2oparo := '000000111111'O
+
+testcase hex_to_oct() runs on PDTestComponent{
+
+ if ((h2opar == hex2oct(''H))
+ and (h2opar == ''O))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2opar1 == hex2oct('000000'H & ''H & '111111'H))
+ and (h2opar1 == h2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2opar2 == hex2oct(substr('000000111111'H,0,6) & ''H & substr('000000111111'H,6,6)))
+ and (h2opar2 == h2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2opar3 == hex2oct(('000000'H <@ 3) & ''H & ('111111'H @> 3)))
+ and (h2opar3 == h2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2opar4 == hex2oct((not4b 'FFFFFF'H) & '111111'H))
+ and (h2opar4 == h2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2opar5 == hex2oct('000000111111'H and4b '000000111111'H))
+ and (h2opar5 == h2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2opar6 == hex2oct('000000000000'H or4b '000000111111'H))
+ and (h2opar6 == h2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2opar7 == hex2oct('000000000000'H xor4b '000000111111'H))
+ and (h2opar7 == h2oparo))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2opar8 == hex2oct('00011'H))
+ and (h2opar8 == '000011'O))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2opar9 == hex2oct('1'H))
+ and (h2opar9 == '01'O))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+
+}
+
+/*--- HEX2STR --------------------------------------------------*/
+
+modulepar charstring h2spar := hex2str(''H)
+modulepar charstring h2spar1 := hex2str('000000'H & ''H & '111111'H)
+modulepar charstring h2spar2 := hex2str(substr('000000111111'H,0,6) & ''H & substr('000000111111'H,6,6))
+modulepar charstring h2spar3 := hex2str(('000000'H <@ 3) & ''H & ('111111'H @> 3))
+modulepar charstring h2spar4 := hex2str((not4b 'FFFFFF'H) & '111111'H)
+modulepar charstring h2spar5 := hex2str('000000111111'H and4b '000000111111'H)
+modulepar charstring h2spar6 := hex2str('000000000000'H or4b '000000111111'H)
+modulepar charstring h2spar7 := hex2str('000000000000'H xor4b '000000111111'H)
+
+modulepar charstring h2spars := "000000111111"
+
+testcase hex_to_str() runs on PDTestComponent{
+
+ if ((h2spar == hex2str(''H))
+ and (h2spar == ""))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2spar1 == hex2str('000000'H & ''H & '111111'H))
+ and (h2spar1 == h2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2spar2 == hex2str(substr('000000111111'H,0,6) & ''H & substr('000000111111'H,6,6)))
+ and (h2spar2 == h2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2spar3 == hex2str(('000000'H <@ 3) & ''H & ('111111'H @> 3)))
+ and (h2spar3 == h2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2spar4 == hex2str((not4b 'FFFFFF'H) & '111111'H))
+ and (h2spar4 == h2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2spar5 == hex2str('000000111111'H and4b '000000111111'H))
+ and (h2spar5 == h2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2spar6 == hex2str('000000000000'H or4b '000000111111'H))
+ and (h2spar6 == h2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((h2spar7 == hex2str('000000000000'H xor4b '000000111111'H))
+ and (h2spar7 == h2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+control {
+ execute (hex_to_bit());
+ execute (hex_to_int());
+ execute (hex_to_oct());
+ execute (hex_to_str());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/hex_to_SW.ttcn b/Regression_Test_java/src/predefFunctions/hex_to_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..e7186c0323b7eba1fb9ad3559387be9ce97f9e59
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/hex_to_SW.ttcn
@@ -0,0 +1,298 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module hex_to_SW { //^In TTCN-3 module `hex_to_SW'://
+
+type component PDTestComponent {};
+
+/*--- HEX2BIT --------------------------------------------------*/
+
+const bitstring h2bcon := hex2bit(''H)
+const bitstring h2bcon1 := hex2bit('000000'H & ''H & '111111'H)
+const bitstring h2bcon2 := hex2bit(substr('000000111111'H,0,6) & ''H & substr('000000111111'H,6,6))
+const bitstring h2bcon3 := hex2bit(('000000'H <@ lengthof(h2bcon2)/2) & ''H & ('111111'H @> lengthof(h2bcon2)/2))
+const bitstring h2bcon4 := hex2bit((not4b 'FFFFFF'H) & '111111'H)
+const bitstring h2bcon5 := hex2bit('000000111111'H and4b '000000111111'H)
+const bitstring h2bcon6 := hex2bit('000000000000'H or4b '000000111111'H)
+const bitstring h2bcon7 := hex2bit('000000000000'H xor4b '000000111111'H)
+
+const bitstring h2bconb := '000000000000000000000000000100010001000100010001'B
+
+testcase hex_to_bit() runs on PDTestComponent{ //In testcase definition//
+
+ if ((h2bcon == hex2bit(''H))
+ and (h2bcon == ''B))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2bcon1 == hex2bit('000000'H & ''H & '111111'H))
+ and (h2bcon1 == h2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2bcon2 == hex2bit(substr('000000111111'H,0,6) & ''H & substr('000000111111'H,6,6)))
+ and (h2bcon2 == h2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2bcon3 == hex2bit(('000000'H <@ lengthof(h2bcon2)/2) & ''H & ('111111'H @> lengthof(h2bcon2)/2)))
+ and (h2bcon3 == h2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2bcon4 == hex2bit((not4b 'FFFFFF'H) & '111111'H))
+ and (h2bcon4 == h2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2bcon5 == hex2bit('000000111111'H and4b '000000111111'H))
+ and (h2bcon5 == h2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2bcon6 == hex2bit('000000000000'H or4b '000000111111'H))
+ and (h2bcon6 == h2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2bcon7 == hex2bit('000000000000'H xor4b '000000111111'H))
+ and (h2bcon7 == h2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+}
+/*--- HEX2INT --------------------------------------------------*/
+
+const integer h2icon := hex2int(''H)
+const integer h2icon1 := hex2int('FFF'H & 'FFFF'H)
+const integer h2icon2 := hex2int((not4b 'FFF'H) & 'FFFF'H)
+const integer h2icon3 := hex2int(('FFF'H and4b '000'H) & 'FFFF'H)
+const integer h2icon4 := hex2int(('000'H or4b '000'H) & 'FFFF'H)
+const integer h2icon5 := hex2int(('0FF'H xor4b '0FF'H) & 'FFFF'H)
+const integer i1 := 12345678910111213141516
+const hexstring hs1 := '000000000000029D42B65689328BBE0C'H
+
+testcase hex_to_int() runs on PDTestComponent{ //In testcase definition//
+
+ if ((h2icon == hex2int(''H))
+ and (h2icon == 0))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2icon1 == hex2int('FFF'H & 'FFFF'H))
+ and (h2icon1 == 268435455))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2icon2 == hex2int((not4b 'FFF'H) & 'FFFF'H))
+ and (h2icon2 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2icon3 == hex2int(('FFF'H and4b '000'H) & 'FFFF'H))
+ and (h2icon3 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2icon4 == hex2int(('000'H or4b '000'H) & 'FFFF'H))
+ and (h2icon4 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2icon5 == hex2int(('0FF'H xor4b '0FF'H) & 'FFFF'H))
+ and (h2icon5 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if (hex2int(hs1) == i1)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (hex2int('000000000000029D42B65689328BBE0C'H) == 12345678910111213141516)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (hex2int(hs1) == 12345678910111213141516)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (hex2int('029D42B65689328BBE0C'H) == 12345678910111213141516)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+
+/*--- HEX2OCT --------------------------------------------------*/
+
+const octetstring h2ocon := hex2oct(''H)
+const octetstring h2ocon1 := hex2oct('000000'H & ''H & '111111'H)
+const octetstring h2ocon2 := hex2oct(substr('000000111111'H,0,6) & ''H & substr('000000111111'H,6,6))
+const octetstring h2ocon3 := hex2oct(('000000'H <@ 3) & ''H & ('111111'H @> 3))
+const octetstring h2ocon4 := hex2oct((not4b 'FFFFFF'H) & '111111'H)
+const octetstring h2ocon5 := hex2oct('000000111111'H and4b '000000111111'H)
+const octetstring h2ocon6 := hex2oct('000000000000'H or4b '000000111111'H)
+const octetstring h2ocon7 := hex2oct('000000000000'H xor4b '000000111111'H)
+const octetstring h2ocon8 := hex2oct('00011'H)
+const octetstring h2ocon9 := hex2oct('1'H)
+
+const octetstring h2ocono := '000000111111'O
+
+testcase hex_to_oct() runs on PDTestComponent{ //In testcase definition//
+
+ if ((h2ocon == hex2oct(''H))
+ and (h2ocon == ''O))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2ocon1 == hex2oct('000000'H & ''H & '111111'H))
+ and (h2ocon1 == h2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2ocon2 == hex2oct(substr('000000111111'H,0,6) & ''H & substr('000000111111'H,6,6)))
+ and (h2ocon2 == h2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2ocon3 == hex2oct(('000000'H <@ 3) & ''H & ('111111'H @> 3)))
+ and (h2ocon3 == h2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2ocon4 == hex2oct((not4b 'FFFFFF'H) & '111111'H))
+ and (h2ocon4 == h2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2ocon5 == hex2oct('000000111111'H and4b '000000111111'H))
+ and (h2ocon5 == h2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2ocon6 == hex2oct('000000000000'H or4b '000000111111'H))
+ and (h2ocon6 == h2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2ocon7 == hex2oct('000000000000'H xor4b '000000111111'H))
+ and (h2ocon7 == h2ocono))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2ocon8 == hex2oct('00011'H))
+ and (h2ocon8 == '000011'O))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2ocon9 == hex2oct('1'H))
+ and (h2ocon9 == '01'O))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- HEX2STR --------------------------------------------------*/
+
+const charstring h2scon := hex2str(''H)
+const charstring h2scon1 := hex2str('000000'H & ''H & '111111'H)
+const charstring h2scon2 := hex2str(substr('000000111111'H,0,6) & ''H & substr('000000111111'H,6,6))
+const charstring h2scon3 := hex2str(('000000'H <@ 3) & ''H & ('111111'H @> 3))
+const charstring h2scon4 := hex2str((not4b 'FFFFFF'H) & '111111'H)
+const charstring h2scon5 := hex2str('000000111111'H and4b '000000111111'H)
+const charstring h2scon6 := hex2str('000000000000'H or4b '000000111111'H)
+const charstring h2scon7 := hex2str('000000000000'H xor4b '000000111111'H)
+
+const charstring h2scons := "000000111111"
+
+testcase hex_to_str() runs on PDTestComponent{ //In testcase definition//
+
+ if ((h2scon == hex2str(''H))
+ and (h2scon == ""))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2scon1 == hex2str('000000'H & ''H & '111111'H))
+ and (h2scon1 == h2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2scon2 == hex2str(substr('000000111111'H,0,6) & ''H & substr('000000111111'H,6,6)))
+ and (h2scon2 == h2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2scon3 == hex2str(('000000'H <@ 3) & ''H & ('111111'H @> 3)))
+ and (h2scon3 == h2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2scon4 == hex2str((not4b 'FFFFFF'H) & '111111'H))
+ and (h2scon4 == h2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2scon5 == hex2str('000000111111'H and4b '000000111111'H))
+ and (h2scon5 == h2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2scon6 == hex2str('000000000000'H or4b '000000111111'H))
+ and (h2scon6 == h2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((h2scon7 == hex2str('000000000000'H xor4b '000000111111'H))
+ and (h2scon7 == h2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+control {
+ execute (hex_to_bit());
+ execute (hex_to_int());
+ execute (hex_to_oct());
+ execute (hex_to_str());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/int_to_OK.ttcn b/Regression_Test_java/src/predefFunctions/int_to_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..629f6b2ec305f0ff087336906ef283d954bca31b
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/int_to_OK.ttcn
@@ -0,0 +1,468 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module int_to_OK {
+
+type component PDTestComponent {};
+
+
+/*--- INT2BIT --------------------------------------------------*/
+
+const bitstring i2bcon := '0000011111000001111100001111'B
+
+modulepar bitstring i2bpar := '0000011111000001111100001111'B
+modulepar bitstring i2bpar1 := int2bit(0,10);
+modulepar bitstring i2bpar2 := int2bit(0,0);
+modulepar bitstring i2bpar3 := int2bit(1,1)
+modulepar bitstring i2bpar4 := int2bit(255,8)
+modulepar bitstring i2bpar5 := int2bit(bit2int(i2bcon),lengthof(i2bcon))
+modulepar bitstring i2bpar6 := not4b int2bit(bit2int(not4b i2bcon),lengthof(i2bcon))
+modulepar bitstring i2bpar7 := int2bit(bit2int(substr(i2bcon,0,lengthof(i2bcon)/2)),lengthof(i2bcon)/2)
+modulepar bitstring i2bpar8 := int2bit(bit2int(substr(i2bcon, lengthof(i2bcon)/2, lengthof(i2bcon)/2)),lengthof(i2bcon)/2)
+
+testcase int_to_bit() runs on PDTestComponent{
+ var integer i1 := 12345678910111213141516
+ var bitstring bs1 := '00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B
+ var bitstring bs2 := '010100111010100001010110110010101101000100100110010100010111011111000001100'B
+ if ((i2bpar1 == '0000000000'B)
+ and (i2bpar1 == int2bit(0,10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2bpar2 == ''B)and (i2bpar2 == int2bit(0,0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2bpar3 == '1'B)and (i2bpar3 == int2bit(1,1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2bpar4 == '11111111'B)and (i2bpar4 == int2bit(255,8)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2bpar5 == i2bpar)and (i2bpar5 == int2bit(bit2int(i2bpar),lengthof(i2bpar))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2bpar6 == i2bpar)and (i2bpar5 == not4b int2bit(bit2int(not4b i2bpar),lengthof(i2bpar))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if (i2bpar == (i2bpar7 & i2bpar8))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if (int2bit(i1, 92) == bs1)
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ /* compile-time
+ if (int2bit(12345678910111213141516, 92) == '00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B)
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ */
+ if (int2bit(12345678910111213141516, 92) == bs1)
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if (int2bit(12345678910111213141516, 75) == bs2)
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+}
+
+/*--- INT2CHAR --------------------------------------------------*/
+
+const integer i2cpari[3] := {0,1,2}
+
+type record of integer i2crtype
+const i2crtype i2cparii := {0,1,2}
+
+modulepar charstring i2cpar1 := int2char(8 mod 6)
+modulepar charstring i2cpar2 := int2char(i2cpari[2])
+modulepar charstring i2cpar3 := int2char(sizeof(i2cpari)-1)
+modulepar charstring i2cpar4 := int2char(sizeof(i2cparii)-1)
+
+testcase int_to_char() runs on PDTestComponent{
+
+ if ((i2cpar1 == int2char(8 mod 6))
+ and (i2cpar1 == ""))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2cpar2 == int2char(i2cpari[2]))
+ and (i2cpar2 == ""))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2cpar3 == int2char(sizeof(i2cpari)-1))
+ and (i2cpar3 == ""))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2cpar4 == int2char(sizeof(i2cparii)-1))
+ and (i2cpar4 == ""))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ var integer j
+ var charstring c
+
+ for (j:=0; j<128; j:=j+1) {
+ if (char2int(int2char(j)) == j)
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ }
+
+}
+
+/*--- INT2UNICHAR --------------------------------------------------*/
+
+
+
+modulepar universal charstring i2uccon1 := int2unichar(1)
+modulepar universal charstring i2uccon2 := int2unichar(256)
+modulepar universal charstring i2uccon3 := int2unichar(65536)
+modulepar universal charstring i2uccon4 := int2unichar(16777216)
+modulepar universal charstring i2uccon5 := int2unichar(2147483647)
+
+
+testcase int_to_unichar() runs on PDTestComponent{
+
+log (i2uccon1)
+log (i2uccon2)
+log (i2uccon3)
+log (i2uccon4)
+log (i2uccon5)
+
+ if ((i2uccon1 == int2unichar(1))
+ and (i2uccon1 == char(0, 0, 0, 1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2uccon2 == int2unichar(256))
+ and (i2uccon2 == char(0, 0, 1, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2uccon3 == int2unichar(65536))
+ and (i2uccon3 == char(0, 1, 0, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2uccon4 == int2unichar(16777216))
+ and (i2uccon4 == char(1, 0, 0, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2uccon5 == int2unichar(2147483647))
+ and (i2uccon5 == char(127, 255, 255, 255)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+}
+
+
+/*--- INT2FLOAT --------------------------------------------------*/
+
+
+const integer i2fpari[3] := {0,1,2}
+
+type record of integer i2frtype;
+const i2frtype i2fparii := {0}
+
+type float i2fflo (-1.0 .. 6.0)
+
+modulepar float i2fpar1 := int2float(3/2)
+modulepar float i2fpar2 := int2float(-3)
+modulepar float i2fpar3 := int2float(lengthof(""))
+modulepar float i2fpar4 := int2float(i2fpari[0])
+modulepar float i2fpar5 := int2float(i2fparii[0])
+modulepar float i2fpar8 := int2float(2147483648)
+modulepar float i2fpar9 := int2float(214748364800)
+modulepar float i2fpar10 := int2float(4294967296)
+
+modulepar i2fflo i2fpar6 := int2float(20/3)
+modulepar i2fflo i2fpar7 := int2float(8 mod 6)
+
+testcase int_to_float() runs on PDTestComponent{
+
+ if ((i2fpar1 == 1.0)
+ and (i2fpar1 == int2float(3/2)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2fpar2 == -3.0)
+ and (i2fpar2 == -3E0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2fpar3 == 0.0)
+ and (i2fpar3 == int2float(lengthof(""))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2fpar4 == 0.0)
+ and (i2fpar4 == int2float(i2fpari[0])))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2fpar5 == 0.0)
+ and (i2fpar5 == int2float(i2fparii[0])))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2fpar6 == 6.0)
+ and (i2fpar6 == int2float(20/3)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2fpar7 == 2.0)
+ and (i2fpar7 == int2float(8 mod 6)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2fpar8 == 2147483648.0)
+ and (i2fpar8 == int2float(2147483648)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2fpar9 == 214748364800.0)
+ and (i2fpar9 == int2float(214748364800)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2fpar10 == 4294967296.0)
+ and (i2fpar10 == int2float(4294967296)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ var float i2fvar1 := 2147483648.0
+ var float i2fvar2 := 214748364800.0
+ var float i2fvar3 := 4294967296.0
+ if ((i2fvar1 == 2147483648.0)
+ and (i2fvar1 == int2float(2147483648)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2fvar2 == 214748364800.0)
+ and (i2fvar2 == int2float(214748364800)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2fvar3 == 4294967296.0)
+ and (i2fvar3 == int2float(4294967296)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+}
+
+/*--- INT2HEX --------------------------------------------------*/
+
+const hexstring i2hcon := '0123456'H
+modulepar hexstring i2hpar := '0123456'H
+modulepar hexstring i2hpar1 := int2hex(0,10)
+modulepar hexstring i2hpar2 := int2hex(0,0)
+modulepar hexstring i2hpar3 := int2hex(15,1)
+modulepar hexstring i2hpar4 := int2hex(hex2int(i2hcon),lengthof(i2hcon))
+modulepar integer i2hpari := hex2int(i2hcon)
+
+testcase int_to_hex() runs on PDTestComponent{
+ var integer i1 := 12345678910111213141516
+ var hexstring hs1 := '000000000000029D42B65689328BBE0C'H
+ var hexstring hs2 := '029D42B65689328BBE0C'H
+ if ((i2hpar1 == '0000000000'H)
+ and (i2hpar1 == int2hex(0,10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2hpar2 == ''H) and (i2hpar2 == int2hex(0,0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2hpar3 == 'F'H)
+ and (i2hpar3 == int2hex(15,1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2hpar4 == i2hpar)
+ and (i2hpar4 == int2hex(hex2int(i2hpar),lengthof(i2hpar))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if (int2hex(i1, 32) == hs1) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ //compile-time: if (int2hex(12345678910111213141516, 32) == '000000000000029D42B65689328BBE0C'H) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ if (int2hex(12345678910111213141516, 32) == hs1) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ if (int2hex(12345678910111213141516, 20) == hs2) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+}
+
+/*--- INT2OCT --------------------------------------------------*/
+
+const octetstring i2ocon := '12345678'O
+modulepar octetstring i2opar := '12345678'O
+modulepar octetstring i2opar1 := int2oct(0,10)
+modulepar octetstring i2opar2 := int2oct(0,0)
+modulepar octetstring i2opar3 := int2oct(15,1)
+modulepar octetstring i2opar4 := int2oct(oct2int(i2ocon),lengthof(i2ocon))
+modulepar octetstring i2opar5 := int2oct(33,8);
+modulepar integer i2opari := oct2int(i2ocon)
+
+testcase int_to_oct() runs on PDTestComponent{
+ var integer i1 := 881883119815076896174081;
+ var octetstring os1 := '00000000000000000000000000000000000000000000BABEFACEDECAFBADF001'O
+ var octetstring os2 := 'BABEFACEDECAFBADF001'O
+ if ((i2opar1 == '00000000000000000000'O)
+ and (i2opar1 == int2oct(0,10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2opar2 == ''O)and (i2opar2 == int2oct(0,0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2opar3 == '0F'O)
+ and (i2opar3 == int2oct(15,1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if (i2opar5 == '0000000000000021'O)
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2opar4 == i2opar)
+ and (i2opar4 == int2oct(oct2int(i2opar),lengthof(i2opar))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ log(i1);
+ log(int2oct(i1, 32));
+ log(os1);
+ if (int2oct(i1, 32) == os1) { setverdict(pass) } else { setverdict(fail, __LINE__, match(int2oct(i1, 32) , os1)) }
+ //compile-time: if (int2oct(12345678910111213141516, 32) == '00000000000000000000000000000000000000000000029D42B65689328BBE0C'O) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ if (int2oct(881883119815076896174081, 32) == os1) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+ if (int2oct(881883119815076896174081, 10) == os2) { setverdict(pass) } else { setverdict(fail, __LINE__) }
+}
+
+/*--- INT2STR --------------------------------------------------*/
+
+const charstring i2scon := "1234567890"
+modulepar charstring i2spar := "1234567890"
+modulepar charstring i2spar1 := int2str(0)
+modulepar charstring i2spar2 := int2str(-1)
+modulepar charstring i2spar3 := int2str(16 mod 3)
+modulepar charstring i2spar4 := int2str(16 rem 3)
+modulepar charstring i2spar5 := int2str(lengthof(i2scon))
+
+const integer i2sconi := str2int(i2scon)
+
+modulepar charstring i2spar6 := int2str(i2sconi)
+const charstring i2scon7 := "1234567891011121314151617181920"
+modulepar charstring i2spar7 := "1234567891011121314151617181920"
+const charstring i2scon8 := "-1234567891011121314151617181920" // Negative values.
+modulepar charstring i2spar8 := "-1234567891011121314151617181920" // Negative values.
+modulepar integer i2spari1 := str2int(i2scon7)
+modulepar integer i2spari2 := str2int(i2scon8)
+
+testcase int_to_str() runs on PDTestComponent{
+
+ var charstring cc := int2str(i2sconi)
+ var charstring vv := "1234567891011121314151617181920"
+ var charstring vv1 := "-1234567891011121314151617181920"
+ var integer ii := str2int(vv)
+ var integer ii1 := str2int(vv1)
+
+ if ((i2spar1 == "0")
+ and (i2spar1 == int2str(0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2spar2 == "-1")
+ and (i2spar2 == int2str(-1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2spar3 == "1")
+ and (i2spar3 == int2str(16 mod 3)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2spar4 == "1")
+ and (i2spar4 == int2str(16 rem 3)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2spar5 == "10")
+ and (i2spar5 == int2str(lengthof(i2spar))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2spar6 == i2spar)
+ and (i2spar6 == int2str(i2sconi)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ // Compile time evaluation. (Positive/negative.)
+ if ((i2spar7 == int2str(1234567891011121314151617181920)
+ and (int2str(1234567891011121314151617181920) == i2spar7)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((int2str(1234567891011121314151617181930 - 10) == i2spar7)
+ and (i2spar7 == int2str(1234567891011121314151617181930 - 10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2spar7 == int2str(i2spari1)
+ and (int2str(i2spari1) == i2spar7)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((int2str(i2spari1 + 10 - 10) == i2spar7)
+ and (i2spar7 == int2str(i2spari1 + 10 - 10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2spar8 == int2str(-1234567891011121314151617181920)
+ and (int2str(1234567891011121314151617181920) == i2spar7)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((int2str(-1234567891011121314151617181930 + 10) == i2spar8)
+ and (i2spar8 == int2str(-1234567891011121314151617181930 + 10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2spar8 == int2str(i2spari2)
+ and (int2str(i2spari2) == i2spar8)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((int2str(i2spari2 + 10 - 10) == i2spar8)
+ and (i2spar8 == int2str(i2spari2 + 10 - 10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ // Run-time evaluation. (Positive/negative.)
+ if ((vv == int2str(1234567891011121314151617181920)
+ and (int2str(1234567891011121314151617181920) == vv)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((int2str(1234567891011121314151617181910 + 10) == vv)
+ and (vv == int2str(1234567891011121314151617181910 + 10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((vv == int2str(ii)
+ and (int2str(1234567891011121314151617181920) == vv)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((int2str(ii + 10 - 10) == vv)
+ and (vv == int2str(ii + 10 - 10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2spari1 == ii)
+ and (ii == i2spari1))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((int2str(i2spari1) == int2str(ii))
+ and (int2str(ii) == int2str(i2spari1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((vv1 == int2str(-1234567891011121314151617181920)
+ and (int2str(-1234567891011121314151617181920) == vv1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((int2str(-1234567891011121314151617181910 - 10) == vv1)
+ and (vv1 == int2str(-1234567891011121314151617181910 - 10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((vv1 == int2str(ii1)
+ and (int2str(-1234567891011121314151617181920) == vv1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((int2str(ii1 + 10 - 10) == vv1)
+ and (vv1 == int2str(ii1 + 10 - 10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((i2spari2 == ii1)
+ and (ii1 == i2spari2))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((int2str(i2spari2) == int2str(ii1))
+ and (int2str(ii1) == int2str(i2spari2)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+}
+
+
+
+
+control {
+ execute (int_to_bit());
+ execute (int_to_char());
+ execute (int_to_unichar());
+
+ execute (int_to_float());
+ execute (int_to_hex());
+ execute (int_to_oct());
+ execute (int_to_str());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/int_to_SW.ttcn b/Regression_Test_java/src/predefFunctions/int_to_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..3e37836cffe5bea6d93ceb41f042b7476b5f18be
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/int_to_SW.ttcn
@@ -0,0 +1,449 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module int_to_SW { //^In TTCN-3 module `int_to_SW'://
+
+type component PDTestComponent {};
+
+
+/*--- INT2BIT --------------------------------------------------*/
+
+const bitstring i2bcon := '0000011111000001111100001111'B
+const bitstring i2bcon1 := int2bit(0,10);
+const bitstring i2bcon2 := int2bit(0,0);
+const bitstring i2bcon3 := int2bit(1,1)
+const bitstring i2bcon4 := int2bit(255,8)
+const bitstring i2bcon5 := int2bit(bit2int(i2bcon),lengthof(i2bcon))
+const bitstring i2bcon6 := not4b int2bit(bit2int(not4b i2bcon),lengthof(i2bcon))
+const bitstring i2bcon7 := int2bit(bit2int(substr(i2bcon,0,lengthof(i2bcon)/2)),lengthof(i2bcon)/2)
+const bitstring i2bcon8 := int2bit(bit2int(substr(i2bcon,lengthof(i2bcon)/2,lengthof(i2bcon)/2)),lengthof(i2bcon)/2)
+const integer i1 := 12345678910111213141516
+const bitstring bs1 := '00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B
+
+testcase int_to_bit() runs on PDTestComponent{ //In testcase definition//
+ if ((i2bcon1 == '0000000000'B)
+ and (i2bcon1 == int2bit(0,10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2bcon2 == ''B)and (i2bcon2 == int2bit(0,0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2bcon3 == '1'B)and (i2bcon3 == int2bit(1,1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2bcon4 == '11111111'B)and (i2bcon4 == int2bit(255,8)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2bcon5 == i2bcon)and (i2bcon5 == int2bit(bit2int(i2bcon),lengthof(i2bcon))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2bcon6 == i2bcon)and (i2bcon5 == not4b int2bit(bit2int(not4b i2bcon),lengthof(i2bcon))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (i2bcon == (i2bcon7 & i2bcon8))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (int2bit(i1, 92) == bs1)
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (int2bit(12345678910111213141516, 92) == '00000000000000000010100111010100001010110110010101101000100100110010100010111011111000001100'B)
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (int2bit(12345678910111213141516, 92) == bs1)
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (int2bit(12345678910111213141516, 75) == '010100111010100001010110110010101101000100100110010100010111011111000001100'B)
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- INT2CHAR --------------------------------------------------*/
+
+const integer i2cconi[3] := {0,1,2}
+
+type record of integer i2crtype
+const i2crtype i2cconii := {0,1,2}
+
+const char i2ccon1 := int2char(8 mod 6) //^warning: Obsolete type `char' was substituted with `charstring'//
+const char i2ccon2 := int2char(i2cconi[2]) //^warning: Obsolete type `char' was substituted with `charstring'//
+const char i2ccon3 := int2char(sizeof(i2cconi)-1) //^warning: Obsolete type `char' was substituted with `charstring'//
+const char i2ccon4 := int2char(sizeof(i2cconii)-1) //^warning: Obsolete type `char' was substituted with `charstring'//
+
+testcase int_to_char() runs on PDTestComponent{ //In testcase definition//
+
+ if ((i2ccon1 == int2char(8 mod 6))
+ and (i2ccon1 == ""))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2ccon2 == int2char(i2cconi[2]))
+ and (i2ccon2 == ""))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2ccon3 == int2char(sizeof(i2cconi)-1))
+ and (i2ccon3 == ""))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2ccon4 == int2char(sizeof(i2cconii)-1))
+ and (i2ccon4 == ""))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- INT2UNICHAR --------------------------------------------------*/
+
+
+
+const universal char i2uccon1 := int2unichar(1) //^warning: Obsolete type `universal char' was substituted with `universal charstring'//
+const universal char i2uccon2 := int2unichar(256) //^warning: Obsolete type `universal char' was substituted with `universal charstring'//
+const universal char i2uccon3 := int2unichar(65536) //^warning: Obsolete type `universal char' was substituted with `universal charstring'//
+const universal char i2uccon4 := int2unichar(16777216) //^warning: Obsolete type `universal char' was substituted with `universal charstring'//
+const universal char i2uccon5 := int2unichar(2147483647) //^warning: Obsolete type `universal char' was substituted with `universal charstring'//
+
+
+testcase int_to_unichar() runs on PDTestComponent{ //In testcase definition//
+
+//log (i2uccon1)
+//log (i2uccon2)
+//log (i2uccon3)
+//log (i2uccon4)
+//log (i2uccon5)
+
+ if ((i2uccon1 == int2unichar(1))
+ and (i2uccon1 == char(0, 0, 0, 1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2uccon2 == int2unichar(256))
+ and (i2uccon2 == char(0, 0, 1, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2uccon3 == int2unichar(65536))
+ and (i2uccon3 == char(0, 1, 0, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2uccon4 == int2unichar(16777216))
+ and (i2uccon4 == char(1, 0, 0, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2uccon5 == int2unichar(2147483647))
+ and (i2uccon5 == char(127, 255, 255, 255)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+}
+
+
+/*--- INT2FLOAT --------------------------------------------------*/
+
+
+const integer i2fconi[3] := {0,1,2}
+
+type record of integer i2frtype;
+const i2frtype i2fconii := {0}
+
+type float i2fflo (-1.0 .. 6.0)
+
+const float i2fcon1 := int2float(3/2)
+const float i2fcon2 := int2float(-3)
+const float i2fcon3 := int2float(lengthof(""))
+const float i2fcon4 := int2float(i2fconi[0])
+const float i2fcon5 := int2float(i2fconii[0])
+const float i2fcon8 := int2float(2147483648)
+const float i2fcon9 := int2float(214748364800)
+const float i2fcon10 := int2float(4294967296)
+
+const i2fflo i2fcon6 := int2float(20/3)
+const i2fflo i2fcon7 := int2float(8 mod 6)
+
+testcase int_to_float() runs on PDTestComponent{ //In testcase definition//
+
+ if ((i2fcon1 == 1.0)
+ and (i2fcon1 == int2float(3/2)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2fcon2 == -3.0)
+ and (i2fcon2 == -3E0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2fcon3 == 0.0)
+ and (i2fcon3 == int2float(lengthof(""))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2fcon4 == 0.0)
+ and (i2fcon4 == int2float(i2fconi[0])))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2fcon5 == 0.0)
+ and (i2fcon5 == int2float(i2fconii[0])))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2fcon6 == 6.0)
+ and (i2fcon6 == int2float(20/3)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2fcon7 == 2.0)
+ and (i2fcon7 == int2float(8 mod 6)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2fcon8 == 2147483648.0)
+ and (i2fcon8 == int2float(2147483648)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2fcon9 == 214748364800.0)
+ and (i2fcon9 == int2float(214748364800)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2fcon10 == 4294967296.0)
+ and (i2fcon10 == int2float(4294967296)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- INT2HEX --------------------------------------------------*/
+
+const hexstring i2hcon := '0123456'H
+const hexstring i2hcon1 := int2hex(0,10)
+const hexstring i2hcon2 := int2hex(0,0)
+const hexstring i2hcon3 := int2hex(15,1)
+const hexstring i2hcon4 := int2hex(hex2int(i2hcon),lengthof(i2hcon))
+const integer i2hconi := hex2int(i2hcon)
+const hexstring hs1 := '000000000000029D42B65689328BBE0C'H
+
+testcase int_to_hex() runs on PDTestComponent{ //In testcase definition//
+
+ if ((i2hcon1 == '0000000000'H)
+ and (i2hcon1 == int2hex(0,10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2hcon2 == ''H)
+ and (i2hcon2 == int2hex(0,0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2hcon3 == 'F'H)
+ and (i2hcon3 == int2hex(15,1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2hcon4 == i2hcon)
+ and (i2hcon4 == int2hex(hex2int(i2hcon),lengthof(i2hcon))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (int2hex(i1, 32) == hs1)
+ { setverdict(pass) }
+ else { setverdict(fail, __LINE__) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (int2hex(12345678910111213141516, 32) == '000000000000029D42B65689328BBE0C'H)
+ { setverdict(pass) }
+ else { setverdict(fail, __LINE__) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (int2hex(12345678910111213141516, 32) == hs1)
+ { setverdict(pass) }
+ else { setverdict(fail, __LINE__) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (int2hex(12345678910111213141516, 20) == '029D42B65689328BBE0C'H)
+ { setverdict(pass) }
+ else { setverdict(fail, __LINE__) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- INT2OCT --------------------------------------------------*/
+
+const octetstring i2ocon := '12345678'O
+const octetstring i2ocon1 := int2oct(0,10)
+const octetstring i2ocon2 := int2oct(0,0)
+const octetstring i2ocon3 := int2oct(15,1)
+const octetstring i2ocon4 := int2oct(oct2int(i2ocon),lengthof(i2ocon))
+const octetstring i2ocon5 := int2oct(33,8);
+const integer i2oconi := oct2int(i2ocon)
+const octetstring os1 := '00000000000000000000000000000000000000000000029D42B65689328BBE0C'O
+
+testcase int_to_oct() runs on PDTestComponent{ //In testcase definition//
+ if ((i2ocon1 == '00000000000000000000'O)
+ and (i2ocon1 == int2oct(0,10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2ocon2 == ''O)and (i2ocon2 == int2oct(0,0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2ocon3 == '0F'O)
+ and (i2ocon3 == int2oct(15,1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (i2ocon5 == '0000000000000021'O)
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2ocon4 == i2ocon)
+ and (i2ocon4 == int2oct(oct2int(i2ocon),lengthof(i2ocon))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (int2oct(i1, 32) == os1)
+ { setverdict(pass) }
+ else { setverdict(fail, __LINE__) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (int2oct(12345678910111213141516, 32) == '00000000000000000000000000000000000000000000029D42B65689328BBE0C'O)
+ { setverdict(pass) }
+ else { setverdict(fail, __LINE__) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (int2oct(12345678910111213141516, 32) == os1)
+ { setverdict(pass) }
+ else { setverdict(fail, __LINE__) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (int2oct(12345678910111213141516, 10) == '029D42B65689328BBE0C'O)
+ { setverdict(pass) }
+ else { setverdict(fail, __LINE__) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- INT2STR --------------------------------------------------*/
+
+const charstring i2scon := "1234567890"
+const charstring i2scon1 := int2str(0)
+const charstring i2scon2 := int2str(-1)
+const charstring i2scon3 := int2str(16 mod 3)
+const charstring i2scon4 := int2str(16 rem 3)
+const charstring i2scon5 := int2str(lengthof(i2scon))
+
+const integer i2sconi := str2int(i2scon)
+
+const charstring i2scon6 := int2str(i2sconi)
+const charstring i2scon7 := "1234567891011121314151617181920"
+const charstring i2scon8 := "-1234567891011121314151617181920" // Negative values.
+const integer i2sconi1 := str2int(i2scon7)
+const integer i2sconi2 := str2int(i2scon8)
+
+testcase int_to_str() runs on PDTestComponent{ //In testcase definition//
+
+ if ((i2scon1 == "0")
+ and (i2scon1 == int2str(0)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2scon2 == "-1")
+ and (i2scon2 == int2str(-1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2scon3 == "1")
+ and (i2scon3 == int2str(16 mod 3)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2scon4 == "1")
+ and (i2scon4 == int2str(16 rem 3)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2scon5 == "10")
+ and (i2scon5 == int2str(lengthof(i2scon))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2scon6 == i2scon)
+ and (i2scon6 == int2str(i2sconi)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ // Compile time evaluation. (Positive/negative.)
+ if ((i2scon7 == int2str(1234567891011121314151617181920)
+ and (int2str(1234567891011121314151617181920) == i2scon7)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((int2str(1234567891011121314151617181930 - 10) == i2scon7)
+ and (i2scon7 == int2str(1234567891011121314151617181930 - 10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2scon7 == int2str(i2sconi1)
+ and (int2str(i2sconi1) == i2scon7)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((int2str(i2sconi1 + 10 - 10) == i2scon7)
+ and (i2scon7 == int2str(i2sconi1 + 10 - 10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2scon8 == int2str(-1234567891011121314151617181920)
+ and (int2str(1234567891011121314151617181920) == i2scon7)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((int2str(-1234567891011121314151617181930 + 10) == i2scon8)
+ and (i2scon8 == int2str(-1234567891011121314151617181930 + 10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((i2scon8 == int2str(i2sconi2)
+ and (int2str(i2sconi2) == i2scon8)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((int2str(i2sconi2 + 10 - 10) == i2scon8)
+ and (i2scon8 == int2str(i2sconi2 + 10 - 10)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+
+
+
+control {
+ execute (int_to_bit());
+ execute (int_to_char());
+ execute (int_to_unichar());
+
+ execute (int_to_float());
+ execute (int_to_hex());
+ execute (int_to_oct());
+ execute (int_to_str());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/isprecho_OK.ttcn b/Regression_Test_java/src/predefFunctions/isprecho_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..76066a024da147d992c37fc74e3a4b18d23f39ea
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/isprecho_OK.ttcn
@@ -0,0 +1,367 @@
+/******************************************************************************
+ * 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
+ * Delic, Adam
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module isprecho_OK {
+
+type component PDTestComponent {};
+
+/*--- ISPRESENT --------------------------------------------------*/
+
+type record iptype1 {integer i optional}
+type record iptype2 {integer i, iptype1 r optional}
+type set iptype3 {integer i optional}
+type set iptype4 {integer i, iptype3 r optional}
+
+const iptype1 ipcon1 := {1}
+const iptype1 ipcon2 := {omit}
+const iptype2 ipcon3 := {1, {1}}
+const iptype2 ipcon4 := {1, {omit}}
+const iptype3 ipcon5 := {i := 1}
+const iptype3 ipcon6 := {i := omit}
+const iptype4 ipcon7 := {i := 1, r := {i := 1}}
+const iptype4 ipcon8 := {i := 1, r := {i := omit}}
+const iptype2 ipcon9 := {1, omit}
+const iptype4 ipcon10 := {i := 1, r := omit}
+
+
+
+modulepar boolean ipbool1 := ispresent(ipcon1.i)
+modulepar boolean ipbool2 := ispresent(ipcon2.i)
+modulepar boolean ipbool3 := ispresent(ipcon3.r.i)
+modulepar boolean ipbool4 := ispresent(ipcon4.r.i)
+modulepar boolean ipbool5 := ispresent(ipcon5.i)
+modulepar boolean ipbool6 := ispresent(ipcon6.i)
+modulepar boolean ipbool7 := ispresent(ipcon7.r.i)
+modulepar boolean ipbool8 := ispresent(ipcon8.r.i)
+modulepar boolean ipbool9 := ispresent(ipcon9.r)
+modulepar boolean ipbool10 := ispresent(ipcon10.r)
+
+
+testcase ispres() runs on PDTestComponent{
+
+ if (ipbool1 and ispresent(ipcon1.i))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not ipbool2 and not ispresent(ipcon2.i))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (ipbool3 and ispresent(ipcon3.r.i))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not ipbool4 and not ispresent(ipcon4.r.i))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (ipbool5 and ispresent(ipcon5.i))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not ipbool6 and not ispresent(ipcon6.i))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (ipbool7 and ispresent(ipcon7.r.i))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not ipbool8 and not ispresent(ipcon8.r.i))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not ipbool9 and not ispresent(ipcon9.r))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not ipbool10 and not ispresent(ipcon10.r))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+type union ictype1 {integer i, boolean b}
+type record of ictype1 ictype2
+
+const ictype1 iccon1 := {i := 1}
+const ictype2 iccon2 := {{i := 1},{b := true}}
+
+modulepar boolean icbool1 := ischosen(iccon1.i)
+modulepar boolean icbool2 := ischosen(iccon1.b)
+modulepar boolean icbool3 := ischosen(iccon2[0].i)
+modulepar boolean icbool4 := ischosen(iccon2[0].b)
+
+testcase ischo() runs on PDTestComponent{
+ if (icbool1 and ischosen(iccon1.i))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not icbool2 and not ischosen(iccon1.b))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if (icbool3 and ischosen(iccon2[0].i))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (not icbool4 and not ischosen(iccon2[0].b))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+
+type record MyRecord {
+ record {
+ boolean innerField1 optional,
+ integer innerField2 optional,
+ MyRecord innerField3 optional
+ } field1 optional,
+ integer field2
+}
+
+type record R { integer f1 optional, integer f2 optional }
+template R t1 := { f1 := 1, f2 := (2..4) }
+template R t2 := { f1 := omit, f2 := (5..7) ifpresent }
+template R t3 := { f1 := *, f2 := ? }
+
+type record RI { integer i optional }
+type record of integer ROI;
+type record of ROI ROROI;
+
+type record R1 { integer i }
+type record R2 { R1 r }
+
+testcase tc_extendedIspresent() runs on PDTestComponent
+{
+ var template ROROI roroi := { {1,2},{3,4},? }
+ if (ispresent(roroi[1])) { setverdict(pass); } else { setverdict(fail); }
+ if (ispresent(roroi[1][1])) { setverdict(pass); } else { setverdict(fail); }
+ if (not ispresent(roroi[1][2])) { setverdict(pass); } else { setverdict(fail); }
+ if (ispresent(roroi[2])) { setverdict(pass); } else { setverdict(fail); }
+ if (not ispresent(roroi[2][1])) { setverdict(pass); } else { setverdict(fail); }
+
+ if (ispresent(ROROI:?)) { setverdict(pass); } else { setverdict(fail); }
+ if (ispresent(RI:{?})) { setverdict(pass); } else { setverdict(fail); }
+ if (ispresent(ispresent("not present"))) { setverdict(pass); } else { setverdict(fail); }
+ if (ispresent(isbound(isvalue(2)))) { setverdict(pass); } else { setverdict(fail); }
+
+ var ROI roi := {1,2,3}
+ var RI ri := { i:=1 }
+ if (ispresent(roi[ri.i])) { setverdict(pass); } else { setverdict(fail); }
+
+ var template R2 tr2 := { r := ? }
+ if (ispresent(tr2.r.i)) { setverdict(pass); } else { setverdict(fail); }
+
+ var MyRecord vl_MyRecord := { field1 := { omit, omit, omit }, field2 := 5 }
+ if (ispresent(vl_MyRecord.field1)) { setverdict(pass); } else { setverdict(fail); }
+ vl_MyRecord.field1 := omit;
+ if (not ispresent(vl_MyRecord.field1)) { setverdict(pass); } else { setverdict(fail); }
+ if (not ispresent(vl_MyRecord.field1.innerField1)) { setverdict(pass); } else { setverdict(fail); }
+ if (not ispresent(vl_MyRecord.field1.innerField3.field2)) { setverdict(pass); } else { setverdict(fail); }
+
+ var template MyRecord vlt_MyRecord := { field1 := ?, field2 := 5 }
+ if (ispresent(vlt_MyRecord.field1)) { setverdict(pass); } else { setverdict(fail); }
+ if (not ispresent(vlt_MyRecord.field1.innerField1)) { setverdict(pass); } else { setverdict(fail); }
+
+ if (ispresent(t1.f1)) { setverdict(pass); } else { setverdict(fail); }
+ if (ispresent(t1.f2)) { setverdict(pass); } else { setverdict(fail); }
+ if (not ispresent(t2.f1)) { setverdict(pass); } else { setverdict(fail); }
+ if (not ispresent(t2.f2)) { setverdict(pass); } else { setverdict(fail); }
+ if (not ispresent(t3.f1)) { setverdict(pass); } else { setverdict(fail); }
+ if (ispresent(t3.f2)) { setverdict(pass); } else { setverdict(fail); }
+}
+
+type record Rec1 { integer f }
+type record Rec2 { integer f optional }
+type union Uni { integer u }
+
+testcase f_TC_isBoundValuePresent_Integer_Template() runs on PDTestComponent
+{
+ var template integer vt_int;
+ if (isbound(vt_int)) {setverdict(fail)}
+ if (isvalue(vt_int)) {setverdict(fail)}
+ if (ispresent(vt_int)) {setverdict(fail)}
+
+ vt_int:=5;
+ if (not isbound(vt_int)) {setverdict(fail)}
+ if (not isvalue(vt_int)) {setverdict(fail)}
+ if (not ispresent(vt_int)) {setverdict(fail)}
+
+ vt_int := omit;
+ if (not isbound(vt_int)) {setverdict(fail)}
+ if (isvalue(vt_int)) {setverdict(fail)}
+ if (ispresent(vt_int)) {setverdict(fail)}
+
+ vt_int:=?;
+ if (not isbound(vt_int)) {setverdict(fail)}
+ if (isvalue(vt_int)) {setverdict(fail)}
+ if (not ispresent(vt_int)) {setverdict(fail)}
+
+ vt_int:=*;
+ if (not isbound(vt_int)) {setverdict(fail)}
+ if (isvalue(vt_int)) {setverdict(fail)}
+ if (ispresent(vt_int)) {setverdict(fail)}
+
+ setverdict(pass);
+}
+
+testcase f_TC_isBoundValuePresent_RecordWithMandatoryField_Template() runs on PDTestComponent
+{
+ var template Rec1 vl_Rec1;
+ if (isbound(vl_Rec1)) {setverdict(fail)}
+ if (isvalue(vl_Rec1)) {setverdict(fail)}
+ if (ispresent(vl_Rec1)) {setverdict(fail)}
+
+ vl_Rec1:=?;
+ if (not isbound(vl_Rec1)) {setverdict(fail)}
+ if (isvalue(vl_Rec1)) {setverdict(fail)}
+ if (not ispresent(vl_Rec1)) {setverdict(fail)}
+
+ if (not isbound(vl_Rec1.f)) {setverdict(fail)}
+ if (isvalue(vl_Rec1.f)) {setverdict(fail)}
+ if (not ispresent(vl_Rec1.f)) {setverdict(fail)}
+
+ vl_Rec1:=*;
+ if (not isbound(vl_Rec1)) {setverdict(fail)}
+ if (isvalue(vl_Rec1)) {setverdict(fail)}
+ if (ispresent(vl_Rec1)) {setverdict(fail)}
+
+ if (isbound(vl_Rec1.f)) {setverdict(fail)}
+ if (isvalue(vl_Rec1.f)) {setverdict(fail)}
+ vl_Rec1:=*;
+ if (ispresent(vl_Rec1.f)) {setverdict(fail)}
+
+ vl_Rec1:={f:=5};
+ if (not isbound(vl_Rec1)) {setverdict(fail)}
+ if (not isvalue(vl_Rec1)) {setverdict(fail)}
+ if (not ispresent(vl_Rec1)) {setverdict(fail)}
+
+ if (not isbound(vl_Rec1.f)) {setverdict(fail)}
+ if (not isvalue(vl_Rec1.f)) {setverdict(fail)}
+ if (not ispresent(vl_Rec1.f)) {setverdict(fail)}
+
+ vl_Rec1:={f:=?};
+ if (not isbound(vl_Rec1)) {setverdict(fail)}
+ if (isvalue(vl_Rec1)) {setverdict(fail)}
+ if (not ispresent(vl_Rec1)) {setverdict(fail)}
+
+ if (not isbound(vl_Rec1.f)) {setverdict(fail)}
+ if (isvalue(vl_Rec1.f)) {setverdict(fail)}
+ if (not ispresent(vl_Rec1.f)) {setverdict(fail)}
+
+ setverdict(pass);
+}
+
+testcase f_TC_isBoundValuePresent_RecordWithOptionalField_Template() runs on PDTestComponent
+{
+ var template Rec2 vl_Rec2;
+ if (isbound(vl_Rec2)) {setverdict(fail)}
+ if (isvalue(vl_Rec2)) {setverdict(fail)}
+ if (ispresent(vl_Rec2)) {setverdict(fail)}
+
+ vl_Rec2:=?;
+ if (not isbound(vl_Rec2)) {setverdict(fail)}
+ if (isvalue(vl_Rec2)) {setverdict(fail)}
+ if (not ispresent(vl_Rec2)) {setverdict(fail)}
+
+ if (not isbound(vl_Rec2.f)) {setverdict(fail)}
+ if (isvalue(vl_Rec2.f)) {setverdict(fail)}
+ vl_Rec2:=?;
+ if (ispresent(vl_Rec2.f)) {setverdict(fail)}
+
+ vl_Rec2:=*;
+ if (not isbound(vl_Rec2)) {setverdict(fail)}
+ if (isvalue(vl_Rec2)) {setverdict(fail)}
+ if (ispresent(vl_Rec2)) {setverdict(fail)}
+
+ if (isbound(vl_Rec2.f)) {setverdict(fail)}
+ if (isvalue(vl_Rec2.f)) {setverdict(fail)}
+ vl_Rec2:=*;
+ if (ispresent(vl_Rec2.f)) {setverdict(fail)}
+
+ vl_Rec2:={f:=5};
+ if (not isbound(vl_Rec2)) {setverdict(fail)}
+ if (not isvalue(vl_Rec2)) {setverdict(fail)}
+ if (not ispresent(vl_Rec2)) {setverdict(fail)}
+
+ if (not isbound(vl_Rec2.f)) {setverdict(fail)}
+ if (not isvalue(vl_Rec2.f)) {setverdict(fail)}
+ if (not ispresent(vl_Rec2.f)) {setverdict(fail)}
+
+ vl_Rec2:={f:=?};
+ if (not isbound(vl_Rec2)) {setverdict(fail)}
+ if (isvalue(vl_Rec2)) {setverdict(fail)}
+ if (not ispresent(vl_Rec2)) {setverdict(fail)}
+
+ if (not isbound(vl_Rec2.f)) {setverdict(fail)}
+ if (isvalue(vl_Rec2.f)) {setverdict(fail)}
+ if (not ispresent(vl_Rec2.f)) {setverdict(fail)}
+
+ vl_Rec2:={f:=*};
+ if (not isbound(vl_Rec2)) {setverdict(fail)}
+ if (isvalue(vl_Rec2)) {setverdict(fail)}
+ if (not ispresent(vl_Rec2)) {setverdict(fail)}
+
+ if (not isbound(vl_Rec2.f)) {setverdict(fail)}
+ if (isvalue(vl_Rec2.f)) {setverdict(fail)}
+ if (ispresent(vl_Rec2.f)) {setverdict(fail)}
+
+ setverdict(pass);
+}
+
+testcase f_TC_isBoundValuePresent_Union_Template() runs on PDTestComponent
+{
+ var template Uni vl_Uni;
+ if (isbound(vl_Uni)) {setverdict(fail)}
+ if (isvalue(vl_Uni)) {setverdict(fail)}
+ if (ispresent(vl_Uni)) {setverdict(fail)}
+
+ vl_Uni:=?;
+ if (not isbound(vl_Uni)) {setverdict(fail)}
+ if (isvalue(vl_Uni)) {setverdict(fail)}
+ if (not ispresent(vl_Uni)) {setverdict(fail)}
+
+ if (not isbound(vl_Uni.u)) {setverdict(fail)}
+ if (isvalue(vl_Uni.u)) {setverdict(fail)}
+ vl_Uni:=?;
+ if (ispresent(vl_Uni.u)) {setverdict(fail)}
+
+ vl_Uni:={u:=5};
+ if (not isbound(vl_Uni)) {setverdict(fail)}
+ if (not isvalue(vl_Uni)) {setverdict(fail)}
+ if (not ispresent(vl_Uni)) {setverdict(fail)}
+
+ if (not isbound(vl_Uni.u)) {setverdict(fail)}
+ if (not isvalue(vl_Uni.u)) {setverdict(fail)}
+ if (not ispresent(vl_Uni.u)) {setverdict(fail)}
+
+ vl_Uni:={u:=?};
+ if (not isbound(vl_Uni)) {setverdict(fail)}
+ if (isvalue(vl_Uni)) {setverdict(fail)}
+ if (not ispresent(vl_Uni)) {setverdict(fail)}
+
+ if (not isbound(vl_Uni.u)) {setverdict(fail)}
+ if (isvalue(vl_Uni.u)) {setverdict(fail)}
+ if (not ispresent(vl_Uni.u)) {setverdict(fail)}
+
+ setverdict(pass);
+}
+
+testcase HO90059() runs on PDTestComponent { // TemplateInstance with ifpresent is not a Value
+ if (log2str(1 ifpresent)=="1 ifpresent") { setverdict(pass) } else { setverdict(fail) }
+ if (ispresent(1 ifpresent)==false) { setverdict(pass) } else { setverdict(fail) }
+ setverdict(pass);
+}
+
+control {
+ execute (ispres());
+ execute (ischo());
+ execute (tc_extendedIspresent());
+ execute (f_TC_isBoundValuePresent_Integer_Template());
+ execute (f_TC_isBoundValuePresent_RecordWithMandatoryField_Template());
+ execute (f_TC_isBoundValuePresent_RecordWithOptionalField_Template());
+ execute (f_TC_isBoundValuePresent_Union_Template());
+ execute (HO90059());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/oct_to_OK.ttcn b/Regression_Test_java/src/predefFunctions/oct_to_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..782869d6c22b37b44611707950d4a99b935906b4
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/oct_to_OK.ttcn
@@ -0,0 +1,284 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module oct_to_OK {
+
+type component PDTestComponent {};
+
+/*--- OCT2BIT --------------------------------------------------*/
+
+modulepar bitstring o2bpar := oct2bit(''O)
+
+modulepar bitstring o2bpar1 := oct2bit('000000'O & ''O & '111111'O)
+modulepar bitstring o2bpar2 := oct2bit(substr('000000111111'O,0,3) & ''O & substr('000000111111'O,3,3))
+modulepar bitstring o2bpar3 := oct2bit(('000000'O <@ 3) & ''O & ('111111'O @> 3))
+modulepar bitstring o2bpar4 := oct2bit((not4b 'FFFFFF'O) & '111111'O)
+modulepar bitstring o2bpar5 := oct2bit('000000111111'O and4b '000000111111'O)
+modulepar bitstring o2bpar6 := oct2bit('000000000000'O or4b '000000111111'O)
+modulepar bitstring o2bpar7 := oct2bit('000000000000'O xor4b '000000111111'O)
+
+const bitstring o2bparb := '000000000000000000000000000100010001000100010001'B
+
+testcase oct_to_bit() runs on PDTestComponent{
+
+ if ((o2bpar == oct2bit(''O))
+ and (o2bpar == ''B))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2bpar1 == oct2bit('000000'O & ''O & '111111'O))
+ and (o2bpar1 == o2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2bpar2 == oct2bit(substr('000000111111'O,0,3) & ''O & substr('000000111111'O,3,3)))
+ and (o2bpar2 == o2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2bpar3 == oct2bit(('000000'O <@ 3) & ''O & ('111111'O @> 3)))
+ and (o2bpar3 == o2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2bpar4 == oct2bit((not4b 'FFFFFF'O) & '111111'O))
+ and (o2bpar4 == o2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2bpar5 == oct2bit('000000111111'O and4b '000000111111'O))
+ and (o2bpar5 == o2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2bpar6 == oct2bit('000000000000'O or4b '000000111111'O))
+ and (o2bpar6 == o2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2bpar7 == oct2bit('000000000000'O xor4b '000000111111'O))
+ and (o2bpar7 == o2bparb))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+/*--- OCT2CHAR --------------------------------------------------*/
+
+
+modulepar charstring o2cpar1 := oct2char(''O)
+modulepar charstring o2cpar2 := oct2char('41'O)
+modulepar charstring o2cpar3 := oct2char(''O & '41'O)
+modulepar charstring o2cpar4 := oct2char('4142434445464748494A4B4C4D4E4F505152535455565758595A'O)
+
+testcase oct_to_char() runs on PDTestComponent{
+
+ if ((o2cpar1 == oct2char(''O))
+ and (o2cpar1 == ""))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((o2cpar2 == oct2char('41'O))
+ and (o2cpar2 == "A"))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((o2cpar3 == oct2char(''O & '41'O))
+ and (o2cpar3 == "A"))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((o2cpar4 == oct2char('4142434445464748494A4B4C4D4E4F505152535455565758595A'O))
+ and (o2cpar4 == "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+
+/*--- OCT2HEX --------------------------------------------------*/
+
+modulepar hexstring o2hpar := oct2hex(''O)
+modulepar hexstring o2hpar1 := oct2hex('000000'O & ''O & '111111'O)
+modulepar hexstring o2hpar2 := oct2hex(substr('000000111111'O,0,3) & ''O & substr('000000111111'O,3,3))
+modulepar hexstring o2hpar3 := oct2hex(('000000'O <@ 3) & ''O & ('111111'O @> 3))
+modulepar hexstring o2hpar4 := oct2hex((not4b 'FFFFFF'O) & '111111'O)
+modulepar hexstring o2hpar5 := oct2hex('000000111111'O and4b '000000111111'O)
+modulepar hexstring o2hpar6 := oct2hex('000000000000'O or4b '000000111111'O)
+modulepar hexstring o2hpar7 := oct2hex('000000000000'O xor4b '000000111111'O)
+
+modulepar hexstring o2hparh := '000000111111'H
+
+testcase oct_to_hex() runs on PDTestComponent{
+
+
+ if ((o2hpar == oct2hex(''O))
+ and (o2hpar == ''H))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2hpar1 == oct2hex('000000'O & ''O & '111111'O))
+ and (o2hpar1 == o2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2hpar2 == oct2hex(substr('000000111111'O,0,3) & ''O & substr('000000111111'O,3,3)))
+ and (o2hpar2 == o2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2hpar3 == oct2hex(('000000'O <@ 3) & ''O & ('111111'O @> 3)))
+ and (o2hpar3 == o2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2hpar4 == oct2hex((not4b 'FFFFFF'O) & '111111'O))
+ and (o2hpar4 == o2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2hpar5 == oct2hex('000000111111'O and4b '000000111111'O))
+ and (o2hpar5 == o2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2hpar6 == oct2hex('000000000000'O or4b '000000111111'O))
+ and (o2hpar6 == o2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2hpar7 == oct2hex('000000000000'O xor4b '000000111111'O))
+ and (o2hpar7 == o2hparh))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+/*--- OCT2INT --------------------------------------------------*/
+
+modulepar integer o2ipar := oct2int(''O)
+modulepar integer o2ipar1 := oct2int('FF'O & 'FFFF'O)
+modulepar integer o2ipar2 := oct2int((not4b 'FF'O) & 'FFFF'O)
+modulepar integer o2ipar3 := oct2int(('FF'O and4b '00'O) & 'FFFF'O)
+modulepar integer o2ipar4 := oct2int(('00'O or4b '00'O) & 'FFFF'O)
+modulepar integer o2ipar5 := oct2int(('0F'O xor4b '0F'O) & 'FFFF'O)
+
+testcase oct_to_int() runs on PDTestComponent{
+ var integer b;
+ var integer i1 := 12345678910111213141516
+ var octetstring os1 := '00000000000000000000000000000000000000000000029D42B65689328BBE0C'O
+ if ((o2ipar == oct2int(''O))
+ and (o2ipar == 0))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((o2ipar1 == oct2int('FF'O & 'FFFF'O))
+ and (o2ipar1 == 16777215))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ b := oct2int((not4b 'FF'O) & 'FFFF'O)
+ if ((o2ipar2 == b)
+ and (o2ipar2 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ b := oct2int(('FF'O and4b '00'O) & 'FFFF'O)
+ if ((o2ipar3 == b)
+ and (o2ipar3 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ b := oct2int(('00'O or4b '00'O) & 'FFFF'O)
+ if ((o2ipar4 == b)
+ and (o2ipar4 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ b := oct2int(('0F'O xor4b '0F'O) & 'FFFF'O)
+ if ((o2ipar5 == b)
+ and (o2ipar5 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ var integer j
+ for (j:=0; j<256; j:=j+1) {
+ if (oct2int(int2oct(j,1)) == j)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+ if (oct2int(os1) == i1) { setverdict(pass) } else { setverdict(fail) }
+ //compile-time: if (oct2int('00000000000000000000000000000000000000000000029D42B65689328BBE0C'O) == 12345678910111213141516) { setverdict(pass) } else { setverdict(fail) }
+ if (oct2int('00000000000000000000000000000000000000000000029D42B65689328BBE0C'O) == i1) { setverdict(pass) } else { setverdict(fail) }
+ if (oct2int('029D42B65689328BBE0C'O) == i1) { setverdict(pass) } else { setverdict(fail) }
+}
+
+/*--- OCT2STR --------------------------------------------------*/
+
+modulepar charstring o2spar := oct2str(''O)
+modulepar charstring o2spar1 := oct2str('000000'O & ''O & '111111'O)
+modulepar charstring o2spar2 := oct2str(substr('000000111111'O,0,3) & ''O & substr('000000111111'O,3,3))
+modulepar charstring o2spar3 := oct2str(('000000'O <@ 3) & ''O & ('111111'O @> 3))
+modulepar charstring o2spar4 := oct2str((not4b 'FFFFFF'O) & '111111'O)
+modulepar charstring o2spar5 := oct2str('000000111111'O and4b '000000111111'O)
+modulepar charstring o2spar6 := oct2str('000000000000'O or4b '000000111111'O)
+modulepar charstring o2spar7 := oct2str('000000000000'O xor4b '000000111111'O)
+
+modulepar charstring o2spars := "000000111111"
+
+testcase oct_to_str() runs on PDTestComponent{
+
+
+ if ((o2spar == oct2str(''O))
+ and (o2spar == ""))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2spar1 == oct2str('000000'O & ''O & '111111'O))
+ and (o2spar1 == o2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2spar2 == oct2str(substr('000000111111'O,0,3) & ''O & substr('000000111111'O,3,3)))
+ and (o2spar2 == o2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2spar3 == oct2str(('000000'O <@ 3) & ''O & ('111111'O @> 3)))
+ and (o2spar3 == o2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2spar4 == oct2str((not4b 'FFFFFF'O) & '111111'O))
+ and (o2spar4 == o2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2spar5 == oct2str('000000111111'O and4b '000000111111'O))
+ and (o2spar5 == o2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2spar6 == oct2str('000000000000'O or4b '000000111111'O))
+ and (o2spar6 == o2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ if ((o2spar7 == oct2str('000000000000'O xor4b '000000111111'O))
+ and (o2spar7 == o2spars))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+
+control {
+ execute (oct_to_bit());
+ execute (oct_to_char());
+ execute (oct_to_hex());
+ execute (oct_to_int());
+ execute (oct_to_str());
+}
+
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/oct_to_SW.ttcn b/Regression_Test_java/src/predefFunctions/oct_to_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..c489d662a9e3a3f0a65a7b49fcea51399c2a9693
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/oct_to_SW.ttcn
@@ -0,0 +1,323 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module oct_to_SW { //^In TTCN-3 module `oct_to_SW'://
+
+type component PDTestComponent {};
+
+/*--- OCT2BIT --------------------------------------------------*/
+
+const bitstring o2bcon := oct2bit(''O)
+const bitstring o2bcon1 := oct2bit('000000'O & ''O & '111111'O)
+const bitstring o2bcon2 := oct2bit(substr('000000111111'O,0,3) & ''O & substr('000000111111'O,3,3))
+const bitstring o2bcon3 := oct2bit(('000000'O <@ 3) & ''O & ('111111'O @> 3))
+const bitstring o2bcon4 := oct2bit((not4b 'FFFFFF'O) & '111111'O)
+const bitstring o2bcon5 := oct2bit('000000111111'O and4b '000000111111'O)
+const bitstring o2bcon6 := oct2bit('000000000000'O or4b '000000111111'O)
+const bitstring o2bcon7 := oct2bit('000000000000'O xor4b '000000111111'O)
+
+const bitstring o2bconb := '000000000000000000000000000100010001000100010001'B
+
+testcase oct_to_bit() runs on PDTestComponent{ //In testcase definition//
+
+ if ((o2bcon == oct2bit(''O))
+ and (o2bcon == ''B))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2bcon1 == oct2bit('000000'O & ''O & '111111'O))
+ and (o2bcon1 == o2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2bcon2 == oct2bit(substr('000000111111'O,0,3) & ''O & substr('000000111111'O,3,3)))
+ and (o2bcon2 == o2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2bcon3 == oct2bit(('000000'O <@ 3) & ''O & ('111111'O @> 3)))
+ and (o2bcon3 == o2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2bcon4 == oct2bit((not4b 'FFFFFF'O) & '111111'O))
+ and (o2bcon4 == o2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2bcon5 == oct2bit('000000111111'O and4b '000000111111'O))
+ and (o2bcon5 == o2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2bcon6 == oct2bit('000000000000'O or4b '000000111111'O))
+ and (o2bcon6 == o2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2bcon7 == oct2bit('000000000000'O xor4b '000000111111'O))
+ and (o2bcon7 == o2bconb))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+}
+
+/*--- OCT2CHAR --------------------------------------------------*/
+
+
+const char o2ccon1 := oct2char(''O) //^warning: Obsolete type `char' was substituted with `charstring'//
+const char o2ccon2 := oct2char('41'O) //^warning: Obsolete type `char' was substituted with `charstring'//
+const char o2ccon3 := oct2char(''O & '41'O) //^warning: Obsolete type `char' was substituted with `charstring'//
+const char o2ccon4 := oct2char('4142434445464748494A4B4C4D4E4F505152535455565758595A'O)//^warning: Obsolete type `char' was substituted with `charstring'//
+
+testcase oct_to_char() runs on PDTestComponent{ //In testcase definition//
+
+ if ((o2ccon1 == oct2char(''O))
+ and (o2ccon1 == ""))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((o2ccon2 == oct2char('41'O))
+ and (o2ccon2 == "A"))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((o2ccon3 == oct2char(''O & '41'O))
+ and (o2ccon3 == "A"))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((o2ccon4 == oct2char('4142434445464748494A4B4C4D4E4F505152535455565758595A'O))
+ and (o2ccon4 == "ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+}
+
+
+/*--- OCT2HEX --------------------------------------------------*/
+
+const hexstring o2hcon := oct2hex(''O)
+const hexstring o2hcon1 := oct2hex('000000'O & ''O & '111111'O)
+const hexstring o2hcon2 := oct2hex(substr('000000111111'O,0,3) & ''O & substr('000000111111'O,3,3))
+const hexstring o2hcon3 := oct2hex(('000000'O <@ 3) & ''O & ('111111'O @> 3))
+const hexstring o2hcon4 := oct2hex((not4b 'FFFFFF'O) & '111111'O)
+const hexstring o2hcon5 := oct2hex('000000111111'O and4b '000000111111'O)
+const hexstring o2hcon6 := oct2hex('000000000000'O or4b '000000111111'O)
+const hexstring o2hcon7 := oct2hex('000000000000'O xor4b '000000111111'O)
+
+const hexstring o2hconh := '000000111111'H
+
+testcase oct_to_hex() runs on PDTestComponent{ //In testcase definition//
+
+ if ((o2hcon == oct2hex(''O))
+ and (o2hcon == ''H))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2hcon1 == oct2hex('000000'O & ''O & '111111'O))
+ and (o2hcon1 == o2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2hcon2 == oct2hex(substr('000000111111'O,0,3) & ''O & substr('000000111111'O,3,3)))
+ and (o2hcon2 == o2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2hcon3 == oct2hex(('000000'O <@ 3) & ''O & ('111111'O @> 3)))
+ and (o2hcon3 == o2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2hcon4 == oct2hex((not4b 'FFFFFF'O) & '111111'O))
+ and (o2hcon4 == o2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2hcon5 == oct2hex('000000111111'O and4b '000000111111'O))
+ and (o2hcon5 == o2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2hcon6 == oct2hex('000000000000'O or4b '000000111111'O))
+ and (o2hcon6 == o2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2hcon7 == oct2hex('000000000000'O xor4b '000000111111'O))
+ and (o2hcon7 == o2hconh))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+}
+
+/*--- OCT2INT --------------------------------------------------*/
+
+const integer o2icon := oct2int(''O)
+const integer o2icon1 := oct2int('FF'O & 'FFFF'O)
+const integer o2icon2 := oct2int((not4b 'FF'O) & 'FFFF'O)
+const integer o2icon3 := oct2int(('FF'O and4b '00'O) & 'FFFF'O)
+const integer o2icon4 := oct2int(('00'O or4b '00'O) & 'FFFF'O)
+const integer o2icon5 := oct2int(('0F'O xor4b '0F'O) & 'FFFF'O)
+const integer i1 := 12345678910111213141516
+const octetstring os1 := '00000000000000000000000000000000000000000000029D42B65689328BBE0C'O
+
+testcase oct_to_int() runs on PDTestComponent{ //In testcase definition//
+
+ if ((o2icon == oct2int(''O))
+ and (o2icon == 0))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((o2icon1 == oct2int('FF'O & 'FFFF'O))
+ and (o2icon1 == 16777215))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2icon2 == oct2int((not4b 'FF'O) & 'FFFF'O))
+ and (o2icon2 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2icon3 == oct2int(('FF'O and4b '00'O) & 'FFFF'O))
+ and (o2icon3 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2icon4 == oct2int(('00'O or4b '00'O) & 'FFFF'O))
+ and (o2icon4 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2icon5 == oct2int(('0F'O xor4b '0F'O) & 'FFFF'O))
+ and (o2icon5 == 65535))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if (oct2int(os1) == i1)
+ { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (oct2int('00000000000000000000000000000000000000000000029D42B65689328BBE0C'O) == 12345678910111213141516)
+ { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (oct2int('00000000000000000000000000000000000000000000029D42B65689328BBE0C'O) == i1)
+ { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (oct2int('029D42B65689328BBE0C'O) == i1)
+ { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- OCT2STR --------------------------------------------------*/
+
+const charstring o2scon := oct2str(''O)
+const charstring o2scon1 := oct2str('000000'O & ''O & '111111'O)
+const charstring o2scon2 := oct2str(substr('000000111111'O,0,3) & ''O & substr('000000111111'O,3,3))
+const charstring o2scon3 := oct2str(('000000'O <@ 3) & ''O & ('111111'O @> 3))
+const charstring o2scon4 := oct2str((not4b 'FFFFFF'O) & '111111'O)
+const charstring o2scon5 := oct2str('000000111111'O and4b '000000111111'O)
+const charstring o2scon6 := oct2str('000000000000'O or4b '000000111111'O)
+const charstring o2scon7 := oct2str('000000000000'O xor4b '000000111111'O)
+
+const charstring o2scons := "000000111111"
+
+testcase oct_to_str() runs on PDTestComponent{ //In testcase definition//
+
+
+ if ((o2scon == oct2str(''O))
+ and (o2scon == ""))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2scon1 == oct2str('000000'O & ''O & '111111'O))
+ and (o2scon1 == o2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2scon2 == oct2str(substr('000000111111'O,0,3) & ''O & substr('000000111111'O,3,3)))
+ and (o2scon2 == o2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2scon3 == oct2str(('000000'O <@ 3) & ''O & ('111111'O @> 3)))
+ and (o2scon3 == o2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2scon4 == oct2str((not4b 'FFFFFF'O) & '111111'O))
+ and (o2scon4 == o2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2scon5 == oct2str('000000111111'O and4b '000000111111'O))
+ and (o2scon5 == o2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2scon6 == oct2str('000000000000'O or4b '000000111111'O))
+ and (o2scon6 == o2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((o2scon7 == oct2str('000000000000'O xor4b '000000111111'O))
+ and (o2scon7 == o2scons))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+}
+
+
+control {
+ execute (oct_to_bit());
+ execute (oct_to_char());
+ execute (oct_to_hex());
+ execute (oct_to_int());
+ execute (oct_to_str());
+}
+
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/replacer_OK.ttcn b/Regression_Test_java/src/predefFunctions/replacer_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..a3f43664a43a44e718520098ab9d931c9ea52012
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/replacer_OK.ttcn
@@ -0,0 +1,138 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module replacer_OK {
+
+type component PDTestComponent {};
+
+/* replace on BITSTRING values. Examples from C.34 of ETSI ES 201 873-1
+ V3.3.1 (2008-02). */
+
+testcase replace_bitstr() runs on PDTestComponent {
+ var integer a := 0
+ var integer b := 1
+ var bitstring bs_1 := replace('00000110'B, 1, 3, '111'B) // returns '01110110'B
+ var bitstring bs_2 := replace('00000110'B, b + a, b + b + b, '111'B)// returns '01110110'B
+ if (bs_1 == '01110110'B) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (bs_1 == bs_2) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+/* replace on HEXSTRING values. */
+
+testcase replace_hexstr() runs on PDTestComponent {
+ var integer a := 0
+ var integer b := 1
+ var hexstring hs_1 := replace('ABCDEF'H, 0, 2, '123'H) // returns '123CDEF'H
+ var hexstring hs_2 := replace('ABCDEF'H, a, b + 1, '123'H)// returns '123CDEF'H
+ if (hs_1 == '123CDEF'H) { setverdict(pass) }
+ else { setverdict(fail, 1) }
+ if (hs_1 == hs_2) { setverdict(pass) }
+ else { setverdict(fail, 2) }
+}
+
+/* replace on OCTETSTRING values. */
+
+testcase replace_octetstr() runs on PDTestComponent {
+ var integer a := 0
+ var integer b := 1
+ var octetstring c := 'FF96'O
+ var octetstring os_0 := '01AB23CD'O
+ var octetstring os_1 := replace('01AB23CD'O, 2, 1, 'FF96'O) // returns '01ABFF96CD'O
+ var octetstring os_2 := replace('01AB23CD'O, a + 2, b, 'FF96'O)// returns '01ABFF96CD'O
+ var octetstring os_3 := replace(os_0, 2, b, c) // returns '01ABFF96CD'O
+ if (os_1 == '01ABFF96CD'O) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (os_2 == '01ABFF96CD'O) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (os_1 == os_2) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (os_2 == os_3) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+/* replace on CHARSTRING values. */
+
+testcase replace_charstr() runs on PDTestComponent {
+ var integer a := 0
+ var integer b := 1
+ var charstring c := "x"
+ var charstring cs_0 := "My name is JJ"
+ var charstring cs_1 := replace("My name is JJ", 11, 1, "xx") // returns "My name is xxJ"
+ var charstring cs_2 := replace("My name is JJ", 11, b - 1, "xx")// returns "My name is xxJJ"
+ var charstring cs_3 := replace("My name is JJ", 2, 2, "x") // returns "Myxame is JJ"
+ var charstring cs_4 := replace("My name is JJ", b + 1, b + 1, c)// returns "Myxame is JJ"
+ var charstring cs_5 := replace("My name is JJ", 13, 0, "xx") // returns "My name is JJxx"
+ var charstring cs_6 := replace(cs_0, 13, a, "xx") // returns "My name is JJxx"
+ /*
+ var charstring cs_7 := replace("My name is JJ", 12, 2, "xx") // produces compile error
+ var charstring cs_8 := replace("My name is JJ", 13, 2, "xx") // produces compile error)
+ */
+ if (cs_1 == "My name is xxJ") { setverdict(pass) }
+ else { setverdict(fail) }
+ if (cs_2 == "My name is xxJJ") { setverdict(pass) }
+ else { setverdict(fail) }
+ if (cs_3 == "Myxame is JJ") { setverdict(pass) }
+ else { setverdict(fail) }
+ if (cs_4 == "Myxame is JJ") { setverdict(pass) }
+ else { setverdict(fail) }
+ if (cs_3 == cs_4) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (cs_5 == "My name is JJxx") { setverdict(pass) }
+ else { setverdict(fail) }
+ if (cs_6 == "My name is JJxx") { setverdict(pass) }
+ else { setverdict(fail) }
+ if (cs_5 == cs_6) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+/* replace on UNIVERSAL_CHARSTRING values. */
+
+testcase replace_ucharstr() runs on PDTestComponent {
+ var integer a := 0
+ var integer b := 1
+ var universal charstring c := char(0, 0, 0, 120) & ""
+ var universal charstring us_0 := char(0, 0, 0, 77) & "y name is JJ"
+ var universal charstring us_1 := replace(char(0, 0, 0, 77) & "y name is JJ", 11, 1, char(0, 0, 0, 120) & "x") // returns "My name is xxJ"
+ var universal charstring us_2 := replace(char(0, 0, 0, 77) & "y name is JJ", 11, b - 1, char(0, 0, 0, 120) & "x")// returns "My name is xxJJ"
+ var universal charstring us_3 := replace(char(0, 0, 0, 77) & "y name is JJ", 2, 2, char(0, 0, 0, 120) & "") // returns "Myxame is JJ"
+ var universal charstring us_4 := replace(char(0, 0, 0, 77) & "y name is JJ", b + 1, b + 1, c) // returns "Myxame is JJ"
+ var universal charstring us_5 := replace(char(0, 0, 0, 77) & "y name is JJ", 13, 0, char(0, 0, 0, 120) & "x") // returns "My name is JJxx"
+ var universal charstring us_6 := replace(us_0, 13, a, char(0, 0, 0, 120) & "x") // returns "My name is JJxx"
+ if (us_1 == char(0, 0, 0, 77) & "y name is xxJ") { setverdict(pass) }
+ else { setverdict(fail) }
+ if (us_2 == char(0, 0, 0, 77) & "y name is xxJJ") { setverdict(pass) }
+ else { setverdict(fail) }
+ if (us_3 == char(0, 0, 0, 77) & "yxame is JJ") { setverdict(pass) }
+ else { setverdict(fail) }
+ if (us_4 == char(0, 0, 0, 77) & "yxame is JJ") { setverdict(pass) }
+ else { setverdict(fail) }
+ if (us_3 == us_4) { setverdict(pass) }
+ else { setverdict(fail) }
+ if (us_5 == char(0, 0, 0, 77) & "y name is JJxx") { setverdict(pass) }
+ else { setverdict(fail) }
+ if (us_6 == char(0, 0, 0, 77) & "y name is JJxx") { setverdict(pass) }
+ else { setverdict(fail) }
+ if (us_5 == us_6) { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+control {
+ execute (replace_bitstr());
+ execute (replace_hexstr());
+ execute (replace_octetstr());
+ execute (replace_charstr());
+ execute (replace_ucharstr());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/replacer_SW.ttcn b/Regression_Test_java/src/predefFunctions/replacer_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..f3983021f2bf2d488b3a46625c4f9a78ac77e860
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/replacer_SW.ttcn
@@ -0,0 +1,158 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module replacer_SW { //^In TTCN-3 module `replacer_SW'://
+
+type component PDTestComponent {};
+
+/* replace on BITSTRING values. Examples from C.34 of ETSI ES 201 873-1
+ V3.3.1 (2008-02). */
+
+const integer a := 0
+const integer b := 1
+const bitstring bs_1 := replace('00000110'B, 1, 3, '111'B) // returns '01110110'B
+const bitstring bs_2 := replace('00000110'B, b + a, b + b + b, '111'B)// returns '01110110'B
+
+testcase replace_bitstr() runs on PDTestComponent { //^In testcase definition//
+ if (bs_1 == '01110110'B) { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (bs_1 == bs_2) { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/* replace on HEXSTRING values. */
+
+const hexstring hs_1 := replace('ABCDEF'H, 0, 2, '123'H) // returns '123CDEF'H
+const hexstring hs_2 := replace('ABCDEF'H, a, b + 1, '123'H)// returns '123CDEF'H
+
+testcase replace_hexstr() runs on PDTestComponent { //^In testcase definition//
+ if (hs_1 == '123CDEF'H) { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (hs_1 == hs_2) { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/* replace on OCTETSTRING values. */
+
+const octetstring c := 'FF96'O
+const octetstring os_0 := '01AB23CD'O
+const octetstring os_1 := replace('01AB23CD'O, 2, 1, 'FF96'O) // returns '01ABFF96CD'O
+const octetstring os_2 := replace('01AB23CD'O, a + 2, b, 'FF96'O)// returns '01ABFF96CD'O
+const octetstring os_3 := replace(os_0, 2, b, c) // returns '01ABFF96CD'O
+
+testcase replace_octetstr() runs on PDTestComponent { //^In testcase definition//
+ if (os_1 == '01ABFF96CD'O) { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (os_2 == '01ABFF96CD'O) { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (os_1 == os_2) { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (os_2 == os_3) { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/* replace on CHARSTRING values. */
+
+const charstring x := "x"
+const charstring cs_0 := "My name is JJ"
+const charstring cs_1 := replace("My name is JJ", 11, 1, "xx") // returns "My name is xxJ"
+const charstring cs_2 := replace("My name is JJ", 11, b - 1, "xx")// returns "My name is xxJJ"
+const charstring cs_3 := replace("My name is JJ", 2, 2, "x") // returns "Myxame is JJ"
+const charstring cs_4 := replace("My name is JJ", b + 1, b + 1, x)// returns "Myxame is JJ"
+const charstring cs_5 := replace("My name is JJ", 13, 0, "xx") // returns "My name is JJxx"
+const charstring cs_6 := replace(cs_0, 13, a, "xx") // returns "My name is JJxx"
+/*
+TODO: move to _SE const charstring cs_7 := replace("My name is JJ", 12, 2, "xx") // produces test case error (compile error)
+ -"- const charstring cs_8 := replace("My name is JJ", 13, 2, "xx") // produces test case error (compile error)
+*/
+testcase replace_charstr() runs on PDTestComponent { //In testcase definition//
+ if (cs_1 == "My name is xxJ") { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (cs_2 == "My name is xxJJ") { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (cs_3 == "Myxame is JJ") { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (cs_4 == "Myxame is JJ") { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (cs_3 == cs_4) { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (cs_5 == "My name is JJxx") { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (cs_6 == "My name is JJxx") { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (cs_5 == cs_6) { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/* replace on UNIVERSAL_CHARSTRING values. */
+
+const universal charstring u := char(0, 0, 0, 120) & ""
+const universal charstring us_0 := char(0, 0, 0, 77) & "y name is JJ"
+const universal charstring us_1 := replace(char(0, 0, 0, 77) & "y name is JJ", 11, 1, char(0, 0, 0, 120) & "x") // returns "My name is xxJ"
+const universal charstring us_2 := replace(char(0, 0, 0, 77) & "y name is JJ", 11, b - 1, char(0, 0, 0, 120) & "x")// returns "My name is xxJJ"
+const universal charstring us_3 := replace(char(0, 0, 0, 77) & "y name is JJ", 2, 2, char(0, 0, 0, 120) & "") // returns "Myxame is JJ"
+const universal charstring us_4 := replace(char(0, 0, 0, 77) & "y name is JJ", b + 1, b + 1, u) // returns "Myxame is JJ"
+const universal charstring us_5 := replace(char(0, 0, 0, 77) & "y name is JJ", 13, 0, char(0, 0, 0, 120) & "x") // returns "My name is JJxx"
+const universal charstring us_6 := replace(us_0, 13, a, char(0, 0, 0, 120) & "x") // returns "My name is JJxx"
+
+testcase replace_ucharstr() runs on PDTestComponent { //In testcase definition//
+ if (us_1 == char(0, 0, 0, 77) & "y name is xxJ") { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (us_2 == char(0, 0, 0, 77) & "y name is xxJJ") { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (us_3 == char(0, 0, 0, 77) & "yxame is JJ") { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (us_4 == char(0, 0, 0, 77) & "yxame is JJ") { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (us_3 == us_4) { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (us_5 == char(0, 0, 0, 77) & "y name is JJxx") { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (us_6 == char(0, 0, 0, 77) & "y name is JJxx") { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (us_5 == us_6) { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+control {
+ execute (replace_bitstr());
+ execute (replace_hexstr());
+ execute (replace_octetstr());
+ execute (replace_charstr());
+ execute (replace_ucharstr());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/rotter_OK.ttcn b/Regression_Test_java/src/predefFunctions/rotter_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..d3da31aecf4cc4e4d6c7b9256b1767eae5fd7b5c
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/rotter_OK.ttcn
@@ -0,0 +1,553 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module rotter_OK {
+
+type component PDTestComponent {};
+
+
+/*--- ROTATE ON BITSTRING --------------------------------------------------*/
+
+const bitstring rotconb := '1000110001'B // '0000000000'B
+modulepar bitstring rotparb1 := rotconb
+modulepar bitstring rotparb2 := rotconb @> 2 // '0110001100'B
+modulepar bitstring rotparb3 := rotconb <@ 2 // '0011000110'B
+modulepar bitstring rotparb4 := rotconb <@ 5 // '1000110001'B
+modulepar bitstring rotparb5 := rotconb @> 5 // '1000110001'B
+modulepar bitstring rotparb6 := rotconb <@ 0 // '1000110001'B
+modulepar bitstring rotparb7 := rotconb @> 0 // '1000110001'B
+modulepar bitstring rotparb8 := rotconb <@ 11 // '0001100011'B
+modulepar bitstring rotparb9 := rotconb @> 11 // '1100011000'B
+modulepar bitstring rotparb10 := ''B
+modulepar bitstring rotparb11 := ''B @> 2
+modulepar bitstring rotparb12 := ''B <@ 2
+modulepar bitstring rotparb13 := ''B @> 0
+modulepar bitstring rotparb14 := ''B <@ 0
+modulepar bitstring rotparb15 := rotconb @> -2 // '0011000110'B
+modulepar bitstring rotparb16 := rotconb <@ -2 // '0110001100'B
+
+testcase rotate_bitstr() runs on PDTestComponent{
+
+ var integer j;
+
+ if (rotparb1 == rotparb1 <@ lengthof(rotparb1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparb1 == rotparb1 @> lengthof(rotparb1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparb1 == rotparb2 <@ 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparb1 == rotparb3 @> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparb1 == rotparb4 @> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparb1 == rotparb5 <@ 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparb1 == rotparb6)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparb1 == rotparb7)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparb8 == '0001100011'B)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparb9 == '1100011000'B)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((rotparb10 == rotparb11)
+ and (rotparb10 == rotparb12))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((rotparb10 == rotparb13)
+ and (rotparb10 == rotparb14))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparb15 == rotparb3)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparb16 == rotparb2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ var bitstring b1 := '0000011111'B
+ for (j:=0; j<15; j:=j+1) {
+ if ((b1 <@ j) @> j == b1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((b1 <@ -j) <@ j == b1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((b1 @> -j) @> j == b1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((b1 @> 0 == b1)
+ and (b1 <@ 0 == b1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+ var bitstring b2 := '10101010101010101010'B
+ for (j:=1; j<30; j:=j+2) {
+ if ((b2 <@ j) != b2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((b2 <@ j-1) == b2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((b2 @> j) != b2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((b2 @> j-1) == b2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+
+}
+
+/*--- ROTATE ON HEXSTRING --------------------------------------------------*/
+
+const hexstring rotconh := '1000110001'H // '0000000000'H
+modulepar hexstring rotparh1 := rotconh
+modulepar hexstring rotparh2 := rotconh @> 2 // '0110001100'H
+modulepar hexstring rotparh3 := rotconh <@ 2 // '0011000110'H
+modulepar hexstring rotparh4 := rotconh <@ 5 // '1000110001'H
+modulepar hexstring rotparh5 := rotconh @> 5 // '1000110001'H
+modulepar hexstring rotparh6 := rotconh <@ 0 // '1000110001'H
+modulepar hexstring rotparh7 := rotconh @> 0 // '1000110001'H
+modulepar hexstring rotparh8 := rotconh <@ 11 // '0001100011'H
+modulepar hexstring rotparh9 := rotconh @> 11 // '1100011000'H
+modulepar hexstring rotparh10 := ''H
+modulepar hexstring rotparh11 := ''H @> 2
+modulepar hexstring rotparh12 := ''H <@ 2
+modulepar hexstring rotparh13 := ''H @> 0
+modulepar hexstring rotparh14 := ''H <@ 0
+modulepar hexstring rotparh15 := rotconh @> -2 // '0011000110'H
+modulepar hexstring rotparh16 := rotconh <@ -2 // '0110001100'H
+
+testcase rotate_hexstr() runs on PDTestComponent{
+
+ var integer j;
+
+
+ if (rotparh1 == rotparh1 <@ lengthof(rotparh1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparh1 == rotparh1 @> lengthof(rotparh1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparh1 == rotparh2 <@ 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparh1 == rotparh3 @> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparh1 == rotparh4 @> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparh1 == rotparh5 <@ 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparh1 == rotparh6)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparh1 == rotparh7)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparh8 == '0001100011'H)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparh9 == '1100011000'H)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((rotparh10 == rotparh11)
+ and (rotparh10 == rotparh12))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((rotparh10 == rotparh13)
+ and (rotparh10 == rotparh14))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparh15 == rotparh3)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparh16 == rotparh2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ var hexstring h1 := '0000011111'H
+ for (j:=0; j<15; j:=j+1) {
+ if ((h1 <@ j) @> j == h1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((h1 <@ -j) <@ j == h1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((h1 @> -j) @> j == h1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((h1 @> 0 == h1)
+ and (h1 <@ 0 == h1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+ var hexstring h2 := '10101010101010101010'H
+ for (j:=1; j<30; j:=j+2) {
+ if ((h2 <@ j) != h2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((h2 <@ j-1) == h2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((h2 @> j) != h2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((h2 @> j-1) == h2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+
+}
+
+/*--- ROTATE ON OCTETSTRING --------------------------------------------------*/
+
+const octetstring rotcono := 'AA00AA00AA'O
+modulepar octetstring rotparo1 := rotcono
+modulepar octetstring rotparo2 := rotcono @> 1 // 'AAAA00AA00'O
+modulepar octetstring rotparo3 := rotcono <@ 1 // '00AA00AAAA'O
+modulepar octetstring rotparo4 := rotcono <@ 5 // 'AA00AA00AA'O
+modulepar octetstring rotparo5 := rotcono @> 5 // 'AA00AA00AA'O
+modulepar octetstring rotparo6 := rotcono <@ 0 // 'AA00AA00AA'O
+modulepar octetstring rotparo7 := rotcono @> 0 // 'AA00AA00AA'O
+modulepar octetstring rotparo8 := rotcono <@ 11 // '00AA00AAAA'O
+modulepar octetstring rotparo9 := rotcono @> 11 // 'AAAA00AA00'O
+modulepar octetstring rotparo10 := ''O
+modulepar octetstring rotparo11 := ''O @> 2
+modulepar octetstring rotparo12 := ''O <@ 2
+modulepar octetstring rotparo13 := ''O @> 0
+modulepar octetstring rotparo14 := ''O <@ 0
+modulepar octetstring rotparo15 := rotcono @> -1 // '00AA00AAAA'O
+modulepar octetstring rotparo16 := rotcono <@ -1 // 'AAAA00AA00'O
+
+testcase rotate_octetstr() runs on PDTestComponent{
+
+ var integer j;
+
+ if (rotparo1 == rotparo1 <@ lengthof(rotparo1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparo1 == rotparo1 @> lengthof(rotparo1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparo1 == rotparo2 <@ 1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparo1 == rotparo3 @> 1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparo1 == rotparo4 @> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparo1 == rotparo5 <@ 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparo1 == rotparo6)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparo1 == rotparo7)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparo8 == '00AA00AAAA'O)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparo9 == 'AAAA00AA00'O)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((rotparo10 == rotparo11)
+ and (rotparo10 == rotparo12))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((rotparo10 == rotparo13)
+ and (rotparo10 == rotparo14))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparo15 == rotparo3)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparo16 == rotparo2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+
+ var octetstring o1 := '0000011111'O
+ for (j:=0; j<15; j:=j+1) {
+ if ((o1 <@ j) @> j == o1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((o1 <@ -j) <@ j == o1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((o1 @> -j) @> j == o1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((o1 @> 0 == o1)
+ and (o1 <@ 0 == o1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+ var octetstring o2 := '1100110011001100110011001100110011001100'O
+ for (j:=1; j<30; j:=j+2) {
+ if ((o2 <@ j) != o2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((o2 <@ j-1) == o2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((o2 @> j) != o2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((o2 @> j-1) == o2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+}
+
+/*--- ROTATE ON CHARSTRING --------------------------------------------------*/
+
+const charstring rotconc := "1000110001" // "0000000000"
+modulepar charstring rotparc1 := rotconc
+modulepar charstring rotparc2 := rotconc @> 2 // "0110001100"
+modulepar charstring rotparc3 := rotconc <@ 2 // "0011000110"
+modulepar charstring rotparc4 := rotconc <@ 5 // "1000110001"
+modulepar charstring rotparc5 := rotconc @> 5 // "1000110001"
+modulepar charstring rotparc6 := rotconc <@ 0 // "1000110001"
+modulepar charstring rotparc7 := rotconc @> 0 // "1000110001"
+modulepar charstring rotparc8 := rotconc <@ 11 // "0001100011"
+modulepar charstring rotparc9 := rotconc @> 11 // "1100011000"
+modulepar charstring rotparc10 := ""
+modulepar charstring rotparc11 := "" @> 2
+modulepar charstring rotparc12 := "" <@ 2
+modulepar charstring rotparc13 := "" @> 0
+modulepar charstring rotparc14 := "" <@ 0
+modulepar charstring rotparc15 := rotconc @> -2 // "0011000110"
+modulepar charstring rotparc16 := rotconc <@ -2 // "0110001100"
+
+testcase rotate_char() runs on PDTestComponent{
+
+ var integer j;
+
+ if (rotparc1 == rotparc1 <@ lengthof(rotparc1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparc1 == rotparc1 @> lengthof(rotparc1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparc1 == rotparc2 <@ 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparc1 == rotparc3 @> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparc1 == rotparc4 @> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparc1 == rotparc5 <@ 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparc1 == rotparc6)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparc1 == rotparc7)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparc8 == "0001100011")
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparc9 == "1100011000")
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((rotparc10 == rotparc11)
+ and (rotparc10 == rotparc12))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((rotparc10 == rotparc13)
+ and (rotparc10 == rotparc14))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparc15 == rotparc3)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparc16 == rotparc2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ var charstring c1 := "0000011111"
+ for (j:=0; j<15; j:=j+1) {
+
+ if ((c1 <@ j) @> j == c1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c1 <@ -j) <@ j == c1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c1 @> -j) @> j == c1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c1 @> 0 == c1)
+ and (c1 <@ 0 == c1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+ var charstring c2 := "10101010101010101010"
+ for (j:=1; j<30; j:=j+2) {
+ if ((c2 <@ j) != c2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2 <@ j-1) == c2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2 @> j) != c2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2 @> j-1) == c2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+
+}
+
+
+/*--- ROTATE ON UNIVERSAL CHARSTRING --------------------------------------------------*/
+
+//modulepar universal charstring rotconuc := "0000000000"
+const universal charstring rotconuc := char(0,0,0,65) & "000" & char(0,0,0,65) & char(0,0,0,65) & "000" & char(0,0,0,65) //A000AA000A
+modulepar universal charstring rotparuc1 := rotconuc
+modulepar universal charstring rotparuc2 := rotconuc @> 2 // "0AA000AA00"
+modulepar universal charstring rotparuc3 := rotconuc <@ 2 // "00AA000AA0"
+modulepar universal charstring rotparuc4 := rotconuc <@ 5 // "A000AA000A"
+modulepar universal charstring rotparuc5 := rotconuc @> 5 // "A000AA000A"
+modulepar universal charstring rotparuc6 := rotconuc <@ 0 // "A000AA000A"
+modulepar universal charstring rotparuc7 := rotconuc @> 0 // "A000AA000A"
+modulepar universal charstring rotparuc8 := rotconuc <@ 11 // "000AA000AA"
+modulepar universal charstring rotparuc9 := rotconuc @> 11 // "AA000AA000"
+modulepar universal charstring rotparuc10 := ""
+modulepar universal charstring rotparuc11 := "" @> 2
+modulepar universal charstring rotparuc12 := "" <@ 2
+modulepar universal charstring rotparuc13 := "" @> 0
+modulepar universal charstring rotparuc14 := "" <@ 0
+modulepar universal charstring rotparuc15 := rotconuc @> -2 // "00AA000AA0"
+modulepar universal charstring rotparuc16 := rotconuc <@ -2 // "0AA000AA00"
+
+testcase rotate_uchar() runs on PDTestComponent{
+
+ var integer j;
+ if (rotparuc1 == rotparuc1 <@ lengthof(rotparc1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparuc1 == rotparuc1 @> lengthof(rotparc1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparuc1 == rotparuc2 <@ 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparuc1 == rotparuc3 @> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparuc1 == rotparuc4 @> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparuc1 == rotparuc5 <@ 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparuc1 == rotparuc6)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparuc1 == rotparuc7)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparuc8 == "000AA000AA")
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparuc9 == "AA000AA000")
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((rotparuc10 == rotparuc11)
+ and (rotparuc10 == rotparuc12))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((rotparuc10 == rotparuc13)
+ and (rotparuc10 == rotparuc14))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparuc15 == rotparuc3)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (rotparuc16 == rotparuc2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ var universal charstring c1 := "0000011111"
+ for (j:=0; j<15; j:=j+1) {
+
+ if ((c1 <@ j) @> j == c1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c1 <@ -j) <@ j == c1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c1 @> -j) @> j == c1)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c1 @> 0 == c1)
+ and (c1 <@ 0 == c1))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+
+ var charstring c2 := "10101010101010101010"
+ for (j:=1; j<30; j:=j+2) {
+ if ((c2 <@ j) != c2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2 <@ j-1) == c2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2 @> j) != c2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((c2 @> j-1) == c2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+}
+
+control {
+ execute (rotate_bitstr());
+ execute (rotate_hexstr());
+ execute (rotate_octetstr());
+ execute (rotate_char());
+ execute (rotate_uchar());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/rotter_SW.ttcn b/Regression_Test_java/src/predefFunctions/rotter_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..ee2eb3ac551e8008348b2f08cbef75fa6b196ca3
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/rotter_SW.ttcn
@@ -0,0 +1,435 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module rotter_SW { //^In TTCN-3 module `rotter_SW'://
+
+type component PDTestComponent {};
+
+
+/*--- ROTATE ON BITSTRING --------------------------------------------------*/
+
+const bitstring rotconb := '0000000000'B
+const bitstring rotconb1 := '1000110001'B
+const bitstring rotconb2 := rotconb1 @> 2 // '0110001100'B
+const bitstring rotconb3 := rotconb1 <@ 2 // '0011000110'B
+const bitstring rotconb4 := rotconb1 <@ 5 // '1000110001'B
+const bitstring rotconb5 := rotconb1 @> 5 // '1000110001'B
+const bitstring rotconb6 := rotconb1 <@ 0 // '1000110001'B
+const bitstring rotconb7 := rotconb1 @> 0 // '1000110001'B
+const bitstring rotconb8 := rotconb1 <@ 11 // '0001100011'B
+const bitstring rotconb9 := rotconb1 @> 11 // '1100011000'B
+const bitstring rotconb10 := ''B
+const bitstring rotconb11 := ''B @> 2
+const bitstring rotconb12 := ''B <@ 2
+const bitstring rotconb13 := ''B @> 0
+const bitstring rotconb14 := ''B <@ 0
+const bitstring rotconb15 := rotconb1 @> -2 // '0011000110'B
+const bitstring rotconb16 := rotconb1 <@ -2 // '0110001100'B
+
+testcase rotate_bitstr() runs on PDTestComponent{ //In testcase definition//
+
+ if (rotconb1 == rotconb1 <@ lengthof(rotconb1))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconb1 == rotconb1 @> lengthof(rotconb1))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconb1 == rotconb2 <@ 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconb1 == rotconb3 @> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconb1 == rotconb4 @> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconb1 == rotconb5 <@ 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconb1 == rotconb6)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconb1 == rotconb7)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconb8 == '0001100011'B)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconb9 == '1100011000'B)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((rotconb10 == rotconb11)
+ and (rotconb10 == rotconb12))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((rotconb10 == rotconb13)
+ and (rotconb10 == rotconb14))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconb15 == rotconb3)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconb16 == rotconb2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- ROTATE ON HEXSTRING --------------------------------------------------*/
+
+const hexstring rotconh := '0000000000'H
+const hexstring rotconh1 := '1000110001'H
+const hexstring rotconh2 := rotconh1 @> 2 // '0110001100'H
+const hexstring rotconh3 := rotconh1 <@ 2 // '0011000110'H
+const hexstring rotconh4 := rotconh1 <@ 5 // '1000110001'H
+const hexstring rotconh5 := rotconh1 @> 5 // '1000110001'H
+const hexstring rotconh6 := rotconh1 <@ 0 // '1000110001'H
+const hexstring rotconh7 := rotconh1 @> 0 // '1000110001'H
+const hexstring rotconh8 := rotconh1 <@ 11 // '0001100011'H
+const hexstring rotconh9 := rotconh1 @> 11 // '1100011000'H
+const hexstring rotconh10 := ''H
+const hexstring rotconh11 := ''H @> 2
+const hexstring rotconh12 := ''H <@ 2
+const hexstring rotconh13 := ''H @> 0
+const hexstring rotconh14 := ''H <@ 0
+const hexstring rotconh15 := rotconh1 @> -2 // '0011000110'H
+const hexstring rotconh16 := rotconh1 <@ -2 // '0110001100'H
+
+testcase rotate_hexstr() runs on PDTestComponent{ //In testcase definition//
+ if (rotconh1 == rotconh1 <@ lengthof(rotconh1))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconh1 == rotconh1 @> lengthof(rotconh1))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconh1 == rotconh2 <@ 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconh1 == rotconh3 @> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconh1 == rotconh4 @> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconh1 == rotconh5 <@ 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconh1 == rotconh6)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconh1 == rotconh7)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconh8 == '0001100011'H)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconh9 == '1100011000'H)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((rotconh10 == rotconh11)
+ and (rotconh10 == rotconh12))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((rotconh10 == rotconh13)
+ and (rotconh10 == rotconh14))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconh15 == rotconh3)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconh16 == rotconh2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- ROTATE ON OCTETSTRING --------------------------------------------------*/
+
+const octetstring rotcono1 := 'AA00AA00AA'O
+const octetstring rotcono2 := rotcono1 @> 1 // 'AAAA00AA00'O
+const octetstring rotcono3 := rotcono1 <@ 1 // '00AA00AAAA'O
+const octetstring rotcono4 := rotcono1 <@ 5 // 'AA00AA00AA'O
+const octetstring rotcono5 := rotcono1 @> 5 // 'AA00AA00AA'O
+const octetstring rotcono6 := rotcono1 <@ 0 // 'AA00AA00AA'O
+const octetstring rotcono7 := rotcono1 @> 0 // 'AA00AA00AA'O
+const octetstring rotcono8 := rotcono1 <@ 11 // '00AA00AAAA'O
+const octetstring rotcono9 := rotcono1 @> 11 // 'AAAA00AA00'O
+const octetstring rotcono10 := ''O
+const octetstring rotcono11 := ''O @> 2
+const octetstring rotcono12 := ''O <@ 2
+const octetstring rotcono13 := ''O @> 0
+const octetstring rotcono14 := ''O <@ 0
+const octetstring rotcono15 := rotcono1 @> -1 // '00AA00AAAA'O
+const octetstring rotcono16 := rotcono1 <@ -1 // 'AAAA00AA00'O
+
+testcase rotate_octetstr() runs on PDTestComponent{ //In testcase definition//
+
+ if (rotcono1 == rotcono1 <@ lengthof(rotcono1))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotcono1 == rotcono1 @> lengthof(rotcono1))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotcono1 == rotcono2 <@ 1)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotcono1 == rotcono3 @> 1)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotcono1 == rotcono4 @> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotcono1 == rotcono5 <@ 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotcono1 == rotcono6)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotcono1 == rotcono7)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotcono8 == '00AA00AAAA'O)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotcono9 == 'AAAA00AA00'O)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((rotcono10 == rotcono11)
+ and (rotcono10 == rotcono12))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((rotcono10 == rotcono13)
+ and (rotcono10 == rotcono14))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotcono15 == rotcono3)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotcono16 == rotcono2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- ROTATE ON CHARSTRING --------------------------------------------------*/
+
+const charstring rotconc := "0000000000"
+const charstring rotconc1 := "1000110001"
+const charstring rotconc2 := rotconc1 @> 2 // "0110001100"
+const charstring rotconc3 := rotconc1 <@ 2 // "0011000110"
+const charstring rotconc4 := rotconc1 <@ 5 // "1000110001"
+const charstring rotconc5 := rotconc1 @> 5 // "1000110001"
+const charstring rotconc6 := rotconc1 <@ 0 // "1000110001"
+const charstring rotconc7 := rotconc1 @> 0 // "1000110001"
+const charstring rotconc8 := rotconc1 <@ 11 // "0001100011"
+const charstring rotconc9 := rotconc1 @> 11 // "1100011000"
+const charstring rotconc10 := ""
+const charstring rotconc11 := "" @> 2
+const charstring rotconc12 := "" <@ 2
+const charstring rotconc13 := "" @> 0
+const charstring rotconc14 := "" <@ 0
+const charstring rotconc15 := rotconc1 @> -2 // "0011000110"
+const charstring rotconc16 := rotconc1 <@ -2 // "0110001100"
+
+testcase rotate_char() runs on PDTestComponent{ //In testcase definition//
+
+ if (rotconc1 == rotconc1 <@ lengthof(rotconc1))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconc1 == rotconc1 @> lengthof(rotconc1))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconc1 == rotconc2 <@ 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconc1 == rotconc3 @> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconc1 == rotconc4 @> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconc1 == rotconc5 <@ 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconc1 == rotconc6)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconc1 == rotconc7)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconc8 == "0001100011")
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconc9 == "1100011000")
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((rotconc10 == rotconc11)
+ and (rotconc10 == rotconc12))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((rotconc10 == rotconc13)
+ and (rotconc10 == rotconc14))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconc15 == rotconc3)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconc16 == rotconc2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+
+/*--- ROTATE ON UNIVERSAL CHARSTRING --------------------------------------------------*/
+
+const universal charstring rotconuc := "0000000000"
+const universal charstring rotconuc1 := char(0,0,0,65) & "000" & char(0,0,0,65) & char(0,0,0,65) & "000" & char(0,0,0,65) //A000AA000A
+const universal charstring rotconuc2 := rotconuc1 @> 2 // "0AA000AA00"
+const universal charstring rotconuc3 := rotconuc1 <@ 2 // "00AA000AA0"
+const universal charstring rotconuc4 := rotconuc1 <@ 5 // "A000AA000A"
+const universal charstring rotconuc5 := rotconuc1 @> 5 // "A000AA000A"
+const universal charstring rotconuc6 := rotconuc1 <@ 0 // "A000AA000A"
+const universal charstring rotconuc7 := rotconuc1 @> 0 // "A000AA000A"
+const universal charstring rotconuc8 := rotconuc1 <@ 11 // "000AA000AA"
+const universal charstring rotconuc9 := rotconuc1 @> 11 // "AA000AA000"
+const universal charstring rotconuc10 := ""
+const universal charstring rotconuc11 := "" @> 2
+const universal charstring rotconuc12 := "" <@ 2
+const universal charstring rotconuc13 := "" @> 0
+const universal charstring rotconuc14 := "" <@ 0
+const universal charstring rotconuc15 := rotconuc1 @> -2 // "00AA000AA0"
+const universal charstring rotconuc16 := rotconuc1 <@ -2 // "0AA000AA00"
+
+testcase rotate_uchar() runs on PDTestComponent{ //In testcase definition//
+
+ if (rotconuc1 == rotconuc1 <@ lengthof(rotconc1))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconuc1 == rotconuc1 @> lengthof(rotconc1))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconuc1 == rotconuc2 <@ 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconuc1 == rotconuc3 @> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconuc1 == rotconuc4 @> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconuc1 == rotconuc5 <@ 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconuc1 == rotconuc6)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconuc1 == rotconuc7)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconuc8 == "000AA000AA")
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconuc9 == "AA000AA000")
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((rotconuc10 == rotconuc11)
+ and (rotconuc10 == rotconuc12))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((rotconuc10 == rotconuc13)
+ and (rotconuc10 == rotconuc14))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconuc15 == rotconuc3)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (rotconuc16 == rotconuc2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+control {
+ execute (rotate_bitstr());
+ execute (rotate_hexstr());
+ execute (rotate_octetstr());
+ execute (rotate_char());
+ execute (rotate_uchar());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/shifty_OK.ttcn b/Regression_Test_java/src/predefFunctions/shifty_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..4f2bacd967259f4105e227d02fe803447e18e11d
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/shifty_OK.ttcn
@@ -0,0 +1,267 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module shifty_OK {
+
+type component PDTestComponent {};
+
+
+/*--- SHIFT ON BITSTRING --------------------------------------------------*/
+
+const bitstring shiconb := '0000000000'B
+const bitstring shiconb1 := '0000110000'B
+modulepar bitstring shiparb := shiconb
+modulepar bitstring shiparb1 := shiconb1
+modulepar bitstring shiparb2 := shiconb1 >> 2 // '0000001100'B
+modulepar bitstring shiparb3 := shiconb1 << 2 // '0011000000'B
+modulepar bitstring shiparb4 := shiconb1 << 5 // '1000000000'B
+modulepar bitstring shiparb5 := shiconb1 >> 5 // '0000000001'B
+modulepar bitstring shiparb6 := shiconb1 << 0 // '0000110000'B
+modulepar bitstring shiparb7 := shiconb1 >> 0 // '0000110000'B
+modulepar bitstring shiparb8 := shiconb1 << 11 // '0000000000'B
+modulepar bitstring shiparb9 := shiconb1 >> 11 // '0000000000'B
+modulepar bitstring shiparb10 := ''B
+modulepar bitstring shiparb11 := ''B >> 2
+modulepar bitstring shiparb12 := ''B << 2
+modulepar bitstring shiparb13 := ''B >> 0
+modulepar bitstring shiparb14 := ''B << 0
+modulepar bitstring shiparb15 := shiconb1 >> -2 // '0011000000'B
+modulepar bitstring shiparb16 := shiconb1 << -2 // '0000001100'B
+
+testcase shift_bitstr() runs on PDTestComponent{
+
+ var integer j;
+
+ if (shiparb1 == shiparb2 << 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparb1 == shiparb3 >> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparb1 != shiparb4 >> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparb1 != shiparb5 << 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparb1 == shiparb6)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparb1 == shiparb7)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparb == shiparb8)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparb == shiparb9)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((shiparb10 == shiparb11)
+ and (shiparb10 == shiparb12))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((shiparb10 == shiparb13)
+ and (shiparb10 == shiparb14))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparb15 == shiparb3)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparb16 == shiparb2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ for (j:=0; j<256; j:=j+1) {
+ if (((int2bit(j,10) << 2) >> 2) == int2bit(j,10))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (((int2bit(j,10) << 2) << -2) == int2bit(j,10))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (((int2bit(j,10) >> -2) >> 2) == int2bit(j,10))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (((int2bit(j,10) >> 0) << 0) == int2bit(j,10))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+}
+
+/*--- SHIFT ON HEXSTRING --------------------------------------------------*/
+
+const hexstring shiconh := '0000000000'H
+const hexstring shiconh1 := '0000110000'H
+modulepar hexstring shiparh := shiconh
+modulepar hexstring shiparh1 := shiconh1
+modulepar hexstring shiparh2 := shiconh1 >> 2 // '0000001100'H
+modulepar hexstring shiparh3 := shiconh1 << 2 // '0011000000'H
+modulepar hexstring shiparh4 := shiconh1 << 5 // '1000000000'H
+modulepar hexstring shiparh5 := shiconh1 >> 5 // '0000000001'H
+modulepar hexstring shiparh6 := shiconh1 << 0 // '0000110000'H
+modulepar hexstring shiparh7 := shiconh1 >> 0 // '0000110000'H
+modulepar hexstring shiparh8 := shiconh1 << 11 // '0000000000'H
+modulepar hexstring shiparh9 := shiconh1 >> 11 // '0000000000'H
+modulepar hexstring shiparh10 := ''H
+modulepar hexstring shiparh11 := ''H >> 2
+modulepar hexstring shiparh12 := ''H << 2
+modulepar hexstring shiparh13 := ''H >> 0
+modulepar hexstring shiparh14 := ''H << 0
+modulepar hexstring shiparh15 := shiconh1 >> -2 // '0011000000'H
+modulepar hexstring shiparh16 := shiconh1 << -2 // '0000001100'H
+
+testcase shift_hexstr() runs on PDTestComponent{
+
+ var integer j;
+
+ if (shiparh1 == shiparh2 << 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparh1 == shiparh3 >> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparh1 != shiparh4 >> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparh1 != shiparh5 << 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparh1 == shiparh6)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparh1 == shiparh7)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparh == shiparh8)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparh == shiparh9)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((shiparh10 == shiparh11)
+ and (shiparh10 == shiparh12))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((shiparh10 == shiparh13)
+ and (shiparh10 == shiparh14))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparh15 == shiparh3)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparh16 == shiparh2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ for (j:=0; j<256; j:=j+1) {
+ if (((int2hex(j,10) << 2) >> 2) == int2hex(j,10))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (((int2hex(j,10) << 2) << -2) == int2hex(j,10))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (((int2hex(j,10) >> -2) >> 2) == int2hex(j,10))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (((int2hex(j,10) >> 0) << 0) == int2hex(j,10))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+}
+
+/*--- SHIFT ON OCTETSTRING --------------------------------------------------*/
+
+const octetstring shicono := '0000000000'O
+const octetstring shicono1 := '0000AA0000'O
+modulepar octetstring shiparo := shicono
+modulepar octetstring shiparo1 := shicono1
+modulepar octetstring shiparo2 := shicono1 >> 2 // '00000000AA'O
+modulepar octetstring shiparo3 := shicono1 << 2 // 'AA00000000'O
+modulepar octetstring shiparo4 := shicono1 << 5 // '0000000000'O
+modulepar octetstring shiparo5 := shicono1 >> 5 // '0000000000'O
+modulepar octetstring shiparo6 := shicono1 << 0 // '0000AA0000'O
+modulepar octetstring shiparo7 := shicono1 >> 0 // '0000AA0000'O
+modulepar octetstring shiparo8 := shicono1 << 11 // '0000000000'O
+modulepar octetstring shiparo9 := shicono1 >> 11 // '0000000000'O
+modulepar octetstring shiparo10 := ''O
+modulepar octetstring shiparo11 := ''O >> 2
+modulepar octetstring shiparo12 := ''O << 2
+modulepar octetstring shiparo13 := ''O >> 0
+modulepar octetstring shiparo14 := ''O << 0
+modulepar octetstring shiparo15 := shicono1 >> -2 // 'AA00000000'O
+modulepar octetstring shiparo16 := shicono1 << -2 // '00000000AA'O
+
+testcase shift_octetstr() runs on PDTestComponent{
+
+ var integer j;
+
+ if (shiparo1 == shiparo2 << 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparo1 == shiparo3 >> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparo1 != shiparo4 >> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparo1 != shiparo5 << 5)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparo1 == shiparo6)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparo1 == shiparo7)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparo == shiparo8)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparo == shiparo9)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((shiparo10 == shiparo11)
+ and (shiparo10 == shiparo12))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((shiparo10 == shiparo13)
+ and (shiparo10 == shiparo14))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparo15 == shiparo3)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (shiparo16 == shiparo2)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ for (j:=0; j<256; j:=j+1) {
+ if (((int2oct(j,3) << 2) >> 2) == int2oct(j,3))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (((int2oct(j,3) << 2) << -2) == int2oct(j,3))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (((int2oct(j,3) >> -2) >> 2) == int2oct(j,3))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (((int2oct(j,3) >> 0) << 0) == int2oct(j,3))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+}
+
+control {
+ execute (shift_bitstr());
+ execute (shift_hexstr());
+ execute (shift_octetstr());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/shifty_SW.ttcn b/Regression_Test_java/src/predefFunctions/shifty_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..054714dabef70ef1251cdf37ce1ce80081b299db
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/shifty_SW.ttcn
@@ -0,0 +1,246 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module shifty_SW { //^In TTCN-3 module `shifty_SW'://
+
+type component PDTestComponent {};
+
+
+/*--- SHIFT ON BITSTRING --------------------------------------------------*/
+
+const bitstring shiconb := '0000000000'B
+const bitstring shiconb1 := '0000110000'B
+const bitstring shiconb2 := shiconb1 >> 2 // '0000001100'B
+const bitstring shiconb3 := shiconb1 << 2 // '0011000000'B
+const bitstring shiconb4 := shiconb1 << 5 // '1000000000'B
+const bitstring shiconb5 := shiconb1 >> 5 // '0000000001'B
+const bitstring shiconb6 := shiconb1 << 0 // '0000110000'B
+const bitstring shiconb7 := shiconb1 >> 0 // '0000110000'B
+const bitstring shiconb8 := shiconb1 << 11 // '0000000000'B
+const bitstring shiconb9 := shiconb1 >> 11 // '0000000000'B
+const bitstring shiconb10 := ''B
+const bitstring shiconb11 := ''B >> 2
+const bitstring shiconb12 := ''B << 2
+const bitstring shiconb13 := ''B >> 0
+const bitstring shiconb14 := ''B << 0
+const bitstring shiconb15 := shiconb1 >> -2 // '0011000000'B
+const bitstring shiconb16 := shiconb1 << -2 // '0000001100'B
+
+testcase shift_bitstr() runs on PDTestComponent{ //In testcase definition//
+
+ if (shiconb1 == shiconb2 << 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconb1 == shiconb3 >> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconb1 != shiconb4 >> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconb1 != shiconb5 << 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconb1 == shiconb6)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconb1 == shiconb7)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconb == shiconb8)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconb == shiconb9)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((shiconb10 == shiconb11)
+ and (shiconb10 == shiconb12))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((shiconb10 == shiconb13)
+ and (shiconb10 == shiconb14))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconb15 == shiconb3)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconb16 == shiconb2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- SHIFT ON HEXSTRING --------------------------------------------------*/
+
+const hexstring shiconh := '0000000000'H
+const hexstring shiconh1 := '0000110000'H
+const hexstring shiconh2 := shiconh1 >> 2 // '0000001100'H
+const hexstring shiconh3 := shiconh1 << 2 // '0011000000'H
+const hexstring shiconh4 := shiconh1 << 5 // '1000000000'H
+const hexstring shiconh5 := shiconh1 >> 5 // '0000000001'H
+const hexstring shiconh6 := shiconh1 << 0 // '0000110000'H
+const hexstring shiconh7 := shiconh1 >> 0 // '0000110000'H
+const hexstring shiconh8 := shiconh1 << 11 // '0000000000'H
+const hexstring shiconh9 := shiconh1 >> 11 // '0000000000'H
+const hexstring shiconh10 := ''H
+const hexstring shiconh11 := ''H >> 2
+const hexstring shiconh12 := ''H << 2
+const hexstring shiconh13 := ''H >> 0
+const hexstring shiconh14 := ''H << 0
+const hexstring shiconh15 := shiconh1 >> -2 // '0011000000'H
+const hexstring shiconh16 := shiconh1 << -2 // '0000001100'H
+
+testcase shift_hexstr() runs on PDTestComponent{ //In testcase definition//
+
+ if (shiconh1 == shiconh2 << 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconh1 == shiconh3 >> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconh1 != shiconh4 >> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconh1 != shiconh5 << 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconh1 == shiconh6)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconh1 == shiconh7)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconh == shiconh8)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconh == shiconh9)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((shiconh10 == shiconh11)
+ and (shiconh10 == shiconh12))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((shiconh10 == shiconh13)
+ and (shiconh10 == shiconh14))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconh15 == shiconh3)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shiconh16 == shiconh2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- SHIFT ON OCTETSTRING --------------------------------------------------*/
+
+const octetstring shicono := '0000000000'O
+const octetstring shicono1 := '0000AA0000'O
+const octetstring shicono2 := shicono1 >> 2 // '00000000AA'O
+const octetstring shicono3 := shicono1 << 2 // 'AA00000000'O
+const octetstring shicono4 := shicono1 << 5 // '0000000000'O
+const octetstring shicono5 := shicono1 >> 5 // '0000000000'O
+const octetstring shicono6 := shicono1 << 0 // '0000AA0000'O
+const octetstring shicono7 := shicono1 >> 0 // '0000AA0000'O
+const octetstring shicono8 := shicono1 << 11 // '0000000000'O
+const octetstring shicono9 := shicono1 >> 11 // '0000000000'O
+const octetstring shicono10 := ''O
+const octetstring shicono11 := ''O >> 2
+const octetstring shicono12 := ''O << 2
+const octetstring shicono13 := ''O >> 0
+const octetstring shicono14 := ''O << 0
+const octetstring shicono15 := shicono1 >> -2 // 'AA00000000'O
+const octetstring shicono16 := shicono1 << -2 // '00000000AA'O
+
+testcase shift_octetstr() runs on PDTestComponent{ //In testcase definition//
+
+ if (shicono1 == shicono2 << 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shicono1 == shicono3 >> 2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shicono1 != shicono4 >> 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shicono1 != shicono5 << 5)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shicono1 == shicono6)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shicono1 == shicono7)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shicono == shicono8)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shicono == shicono9)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((shicono10 == shicono11)
+ and (shicono10 == shicono12))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((shicono10 == shicono13)
+ and (shicono10 == shicono14))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shicono15 == shicono3)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (shicono16 == shicono2)
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+control {
+ execute (shift_bitstr());
+ execute (shift_hexstr());
+ execute (shift_octetstr());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/size_of_OK.ttcn b/Regression_Test_java/src/predefFunctions/size_of_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..42574dea7cabf11ad68064f14011bf7469b8da71
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/size_of_OK.ttcn
@@ -0,0 +1,186 @@
+/******************************************************************************
+ * 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
+ * Beres, Szabolcs
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module size_of_OK { //^In TTCN-3 module `size_of_OK'://
+
+type component PDTestComponent {};
+
+/*--- SIZEOF ON RECORDOF --------------------------------------------------*/
+
+type record of integer sirortype1
+type record of sirortype1 sirortype2
+
+const sirortype1 siro1 := {}
+const sirortype1 siro2 := {1}
+const sirortype1 siro3 := {1,2}
+
+const sirortype2 siro4 := {{}}
+const sirortype2 siro5 := {{},{}}
+const sirortype2 siro6 := {{1},{1,2}}
+
+modulepar integer sirocon1 := sizeof(siro1)
+modulepar integer sirocon2 := sizeof(siro2)
+modulepar integer sirocon3 := sizeof(siro3)
+
+modulepar integer sirocon4 := sizeof(siro4)
+modulepar integer sirocon5 := sizeof(siro5)
+modulepar integer sirocon6 := sizeof(siro5[1])
+modulepar integer sirocon7 := sizeof(siro6[1])
+
+
+testcase sizeof_recof() runs on PDTestComponent{
+
+ if ((sirocon1 == 0)
+ and (sirocon1 == sizeof(siro1)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((sirocon2 == 1)
+ and (sirocon2 == sizeof(siro2)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((sirocon3 == 2)
+ and (sirocon3 == sizeof(siro3)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((sirocon4 == 1)
+ and (sirocon4 == sizeof(siro4)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((sirocon5 == 2)
+ and (sirocon5 == sizeof(siro5)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((sirocon6 == 0)
+ and (sirocon6 == sizeof(siro5[1])))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((sirocon7 == 2)
+ and (sirocon7 == sizeof(siro6[1])))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ var template sirortype1 tr_sirortype1 := {1, 2, 3}
+ if (sizeof(tr_sirortype1) == 3) {
+ setverdict(pass);
+ } else {
+ setverdict(fail);
+ }
+
+}
+
+
+/*--- SIZEOF ON SETOF --------------------------------------------------*/
+
+type set of integer sisostype1
+type set of sisostype1 sisostype2
+
+const sisostype1 siso1 := {}
+const sisostype1 siso2 := {1}
+const sisostype1 siso3 := {1,2}
+const sisostype2 siso4 := {{}}
+const sisostype2 siso5 := {{},{}}
+const sisostype2 siso6 := {{1},{1,2}}
+
+modulepar integer sisocon1 := sizeof(siso1)
+modulepar integer sisocon2 := sizeof(siso2)
+modulepar integer sisocon3 := sizeof(siso3)
+
+modulepar integer sisocon4 := sizeof(siso4)
+modulepar integer sisocon5 := sizeof(siso5)
+modulepar integer sisocon6 := sizeof(siso5[1])
+modulepar integer sisocon7 := sizeof(siso6[1])
+
+
+testcase sizeof_setof() runs on PDTestComponent{ //In testcase definition//
+
+ if ((sisocon1 == 0)
+ and (sisocon1 == sizeof(siso1)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((sisocon2 == 1)
+ and (sisocon2 == sizeof(siso2)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((sisocon3 == 2)
+ and (sisocon3 == sizeof(siso3)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((sisocon4 == 1)
+ and (sisocon4 == sizeof(siso4)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((sisocon5 == 2)
+ and (sisocon5 == sizeof(siso5)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((sisocon6 == 0)
+ and (sisocon6 == sizeof(siso5[1])))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((sisocon7 == 2)
+ and (sisocon7 == sizeof(siso6[1])))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+ var template sisostype1 sisot1 := subset( 1, 2 , 3) length (3..10);
+ var template sisostype1 sisot2 := superset( 1, 2 , 3) length (1..3);
+ var template sisostype1 sisot3 := subset( 1, * , 3) length (1000); //In template variable definition// \
+ //In element 2 of subset// //warning: `\*' in subset\. This template will match everything//
+ if (sizeof(sisot1)==3)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (sizeof(sisot2)==3)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if (sizeof(sisot3)==1000)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+}
+
+/*--- SIZEOF ON ARRAY --------------------------------------------------*/
+
+type record of integer siarrtype
+
+const siarrtype siar1[1] := {{}}
+const siarrtype siar2[1] := {{1}}
+const siarrtype siar3[3] := {{},{1},{1,2}}
+
+
+modulepar integer siarcon1 := sizeof(siar1)
+modulepar integer siarcon2 := sizeof(siar2)
+modulepar integer siarcon3 := sizeof(siar3)
+
+testcase sizeof_array() runs on PDTestComponent{
+
+ if ((siarcon1 == 1)
+ and (siarcon1 == sizeof(siar1)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((siarcon2 == 1)
+ and (siarcon2 == sizeof(siar2)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((siarcon3 == 3)
+ and (siarcon3 == sizeof(siar3)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+control {
+ execute (sizeof_recof());
+ execute (sizeof_setof());
+ execute (sizeof_array());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/size_of_SW.ttcn b/Regression_Test_java/src/predefFunctions/size_of_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..14c8c8f8da9fa7fa37e1f8ce88b47a9d34dea7c0
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/size_of_SW.ttcn
@@ -0,0 +1,216 @@
+/******************************************************************************
+ * 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
+ * Beres, Szabolcs
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module size_of_SW { //^In TTCN-3 module `size_of_SW'://
+
+type port myPort message { inout integer } with { extension "internal" }
+
+type component PDTestComponent {
+ port myPort portArr[5];
+}
+
+/*--- SIZEOF ON RECORDOF --------------------------------------------------*/
+
+type record of integer sirortype1
+type record of sirortype1 sirortype2
+
+type record R {
+ integer i,
+ float f optional
+}
+
+const sirortype1 siro1 := {}
+const sirortype1 siro2 := {1}
+const sirortype1 siro3 := {1,2}
+
+const sirortype2 siro4 := {{}}
+const sirortype2 siro5 := {{},{}}
+const sirortype2 siro6 := {{1},{1,2}}
+
+const integer sirocon1 := sizeof(siro1)
+const integer sirocon2 := sizeof(siro2)
+const integer sirocon3 := sizeof(siro3)
+
+const integer sirocon4 := sizeof(siro4)
+const integer sirocon5 := sizeof(siro5)
+const integer sirocon6 := sizeof(siro5[1])
+const integer sirocon7 := sizeof(siro6[1])
+
+
+testcase sizeof_recof() runs on PDTestComponent{ //^In testcase definition//
+
+ if ((sirocon1 == 0)
+ and (sirocon1 == sizeof(siro1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((sirocon2 == 1)
+ and (sirocon2 == sizeof(siro2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((sirocon3 == 2)
+ and (sirocon3 == sizeof(siro3)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((sirocon4 == 1)
+ and (sirocon4 == sizeof(siro4)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((sirocon5 == 2)
+ and (sirocon5 == sizeof(siro5)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((sirocon6 == 0)
+ and (sirocon6 == sizeof(siro5[1])))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((sirocon7 == 2)
+ and (sirocon7 == sizeof(siro6[1])))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if (sizeof(R: {1, 0.0}) == 2) {
+ setverdict(pass);
+ } else { setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ var template R tr := {1, 0.0};
+ if (sizeof(modifies tr := {2, 1.0}) == 2) {
+ setverdict(pass);
+ } else { setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if (sizeof(modifies tr := {2, omit}) == 1) {
+ setverdict(pass);
+ } else { setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+
+/*--- SIZEOF ON SETOF --------------------------------------------------*/
+
+type set of integer sisostype1
+type set of sisostype1 sisostype2
+
+const sisostype1 siso1 := {}
+const sisostype1 siso2 := {1}
+const sisostype1 siso3 := {1,2}
+const sisostype2 siso4 := {{}}
+const sisostype2 siso5 := {{},{}}
+const sisostype2 siso6 := {{1},{1,2}}
+
+const integer sisocon1 := sizeof(siso1)
+const integer sisocon2 := sizeof(siso2)
+const integer sisocon3 := sizeof(siso3)
+
+const integer sisocon4 := sizeof(siso4)
+const integer sisocon5 := sizeof(siso5)
+const integer sisocon6 := sizeof(siso5[1])
+const integer sisocon7 := sizeof(siso6[1])
+
+
+testcase sizeof_setof() runs on PDTestComponent{ //^In testcase definition//
+
+ if ((sisocon1 == 0)
+ and (sisocon1 == sizeof(siso1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((sisocon2 == 1)
+ and (sisocon2 == sizeof(siso2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((sisocon3 == 2)
+ and (sisocon3 == sizeof(siso3)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((sisocon4 == 1)
+ and (sisocon4 == sizeof(siso4)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((sisocon5 == 2)
+ and (sisocon5 == sizeof(siso5)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((sisocon6 == 0)
+ and (sisocon6 == sizeof(siso5[1])))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((sisocon7 == 2)
+ and (sisocon7 == sizeof(siso6[1])))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- SIZEOF ON ARRAY --------------------------------------------------*/
+
+type record of integer siarrtype
+
+const siarrtype siar1[1] := {{}}
+const siarrtype siar2[1] := {{1}}
+const siarrtype siar3[3] := {{},{1},{1,2}}
+
+
+const integer siarcon1 := sizeof(siar1)
+const integer siarcon2 := sizeof(siar2)
+const integer siarcon3 := sizeof(siar3)
+
+testcase sizeof_array() runs on PDTestComponent{ //^In testcase definition//
+
+ if ((siarcon1 == 1)
+ and (siarcon1 == sizeof(siar1)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((siarcon2 == 1)
+ and (siarcon2 == sizeof(siar2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((siarcon3 == 3)
+ and (siarcon3 == sizeof(siar3)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if (sizeof(portArr) == 5)
+ { setverdict(pass) }
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ timer myTA[2];
+ if (sizeof(myTA) == 2)
+ { setverdict(pass) }
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+}
+
+control {
+ execute (sizeof_recof());
+ execute (sizeof_setof());
+ execute (sizeof_array());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/str_to_OK.ttcn b/Regression_Test_java/src/predefFunctions/str_to_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..18e3c3faabc2adf8c38b265d9bcd7e8d0dc7a866
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/str_to_OK.ttcn
@@ -0,0 +1,635 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module str_to_OK { //^In TTCN-3 module `str_to_OK'://
+
+type component PDTestComponent {};
+
+
+/*--- STR2BIT --------------------------------------------------*/
+
+const bitstring s2bcon := str2bit("")
+modulepar bitstring s2bpar := s2bcon
+modulepar bitstring s2bpar1 := str2bit("000000" & "" & "111111")
+const bitstring s2bcon2 := str2bit(substr("000000111111",0,6) & "" & substr("000000111111",6,6))
+modulepar bitstring s2bpar2 := str2bit(substr("000000111111",0,6) & "" & substr("000000111111",6,6))
+modulepar bitstring s2bpar3 := str2bit(("000000" <@ lengthof(s2bcon2)/2) & "" & ("111111" @> lengthof(s2bcon2)/2))
+
+testcase str_to_bit() runs on PDTestComponent{
+
+
+ if ((s2bpar == str2bit(""))
+ and (s2bpar == ''B))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2bpar1 == str2bit("000000" & "" & "111111"))
+ and (s2bpar1 == '000000111111'B))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2bpar2 == str2bit(substr("000000111111",0,6) & "" & substr("000000111111",6,6)))
+ and (s2bpar2 == '000000111111'B))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2bpar3 == str2bit(("000000" <@ lengthof(s2bpar2)/2) & "" & ("111111" @> lengthof(s2bpar2)/2)))
+ and (s2bpar3 == '000000111111'B))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+
+ var integer j
+ var charstring cc := ""
+ var bitstring bb := ''B
+
+ for (j:=0; j<64; j:=j+1) {
+ cc := cc & bit2str(int2bit(j,j))
+ bb := bb & int2bit(j,j)
+ if (bb == str2bit(cc))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ }
+
+}
+
+/*--- STR2FLOAT --------------------------------------------------*/
+
+//const float s2fcon := str2float("")
+const float s2fcon := str2float("0.0")
+modulepar float s2fpar := str2float("0.0")
+modulepar float s2fpar1 := str2float("12345678901.0")
+modulepar float s2fpar2 := str2float("000000000000" & "12345678901.0") //In module parameter definition// \
+ //In default value// //In the operand of operation `str2float\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation `str2float\(\)'//
+modulepar float s2fpar3 := str2float("-12" & "345678901.0")
+modulepar float s2fpar4 := str2float("1.234E3")
+//modulepar float s2fpar5 := str2float("1.234-3")
+modulepar float s2fpar5 := str2float("1.234")
+//modulepar float s2fpar6 := str2float("1,234E3")
+modulepar float s2fpar6 := str2float("1.0")
+//modulepar float s2fpar7 := str2float("--234")
+
+// HL67862
+modulepar float s2fpar7 := str2float("1");
+modulepar float s2fpar7m:= str2float("-1");
+modulepar float s2fpar8m:= str2float("-1.");
+modulepar float s2fpar8 := str2float("1.");
+modulepar float s2fpar9 := str2float("+001"); //In module parameter definition// \
+ //In default value// //In the operand of operation `str2float\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation `str2float\(\)'//
+modulepar float s2fpar10:= str2float("+001."); //In module parameter definition// \
+ //In default value// //In the operand of operation `str2float\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation `str2float\(\)'//
+modulepar float s2fpar11:= str2float("-0");
+modulepar float s2fpar12:= str2float("-0.");
+modulepar float s2fpar13:= str2float("-0.0");
+
+modulepar float s2fpar14:= str2float("infinity");
+modulepar float s2fpar15:= str2float("-infinity");
+modulepar float s2fpar16:= str2float("not_a_number");
+
+
+
+// modulepar prevents constant folding
+modulepar charstring s2fmp_str := "0.0"
+modulepar charstring s2fmp1_str := "12345678901.0"
+modulepar charstring s2fmp2_str := "000000000000" & "12345678901.0"
+modulepar charstring s2fmp3_str := "-12" & "345678901.0"
+modulepar charstring s2fmp4_str := "1.234E3"
+//modulepar charstring s2fmp5_str := "1.234-3"
+modulepar charstring s2fmp5_str := "1.234"
+//modulepar charstring s2fmp6_str := "1,234E3"
+modulepar charstring s2fmp6_str := "1.0"
+//modulepar charstring s2fmp7_str := "--234"
+
+// HL67862
+modulepar charstring s2fmp7_str := "1";
+modulepar charstring s2fmp7m_str:= "-1";
+modulepar charstring s2fmp8m_str:= "-1.";
+modulepar charstring s2fmp8_str := "1.";
+modulepar charstring s2fmp9_str := "+001";
+modulepar charstring s2fmp10_str:= "+001.";
+modulepar charstring s2fmp11_str:= "-0";
+modulepar charstring s2fmp12_str:= "-0.";
+modulepar charstring s2fmp13_str:= "-0.0";
+
+modulepar charstring s2fmp14_str := "infinity";
+modulepar charstring s2fmp15_str := "-infinity";
+modulepar charstring s2fmp16_str := "not_a_number";
+
+
+//modulepar float s2fmp := str2float("")
+modulepar float s2fmp := str2float("0.0")
+modulepar float s2fmp1 := str2float("12345678901.0")
+modulepar float s2fmp2 := str2float("000000000000" & "12345678901.0") //In module parameter definition// \
+ //In default value// //In the operand of operation `str2float\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation `str2float\(\)'//
+modulepar float s2fmp3 := str2float("-12" & "345678901.0")
+modulepar float s2fmp4 := str2float("1.234E3")
+//modulepar float s2fmp5 := str2float("1.234-3")
+modulepar float s2fmp5 := str2float("1.234")
+//modulepar float s2fmp6 := str2float("1,234E3")
+modulepar float s2fmp6 := str2float("1.0")
+//modulepar float s2fmp7 := str2float("--234")
+
+// HL67862
+modulepar float s2fmp7 := str2float("1");
+modulepar float s2fmp7m:= str2float("-1");
+modulepar float s2fmp8m:= str2float("-1.");
+modulepar float s2fmp8 := str2float("1.");
+modulepar float s2fmp9 := str2float("+001"); //In module parameter definition// \
+ //In default value// //In the operand of operation `str2float\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation `str2float\(\)'//
+modulepar float s2fmp10:= str2float("+001."); //In module parameter definition// \
+ //In default value// //In the operand of operation `str2float\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation `str2float\(\)'//
+modulepar float s2fmp11:= str2float("-0");
+modulepar float s2fmp12:= str2float("-0.");
+modulepar float s2fmp13:= str2float("-0.0");
+
+modulepar float s2fmp14:= str2float("infinity");
+modulepar float s2fmp15:= str2float("-infinity");
+modulepar float s2fmp16:= str2float("not_a_number");
+
+
+
+testcase str_to_float() runs on PDTestComponent{ //In testcase definition//
+
+// compile-time
+ if ((s2fpar == str2float("0.0"))
+ and (s2fpar == 0.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar1 == str2float("12345678901.0"))
+ and (s2fpar1 == 12345678901.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar2 == str2float("000000000000" & "12345678901.0")) //In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation `str2float\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation `str2float\(\)'//
+ and (s2fpar2 == 12345678901.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar3 == str2float("-12" & "345678901.0"))
+ and (s2fpar3 == -12345678901.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar4 == str2float("1.234E3"))
+ and (s2fpar4 == 1234.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar5 == str2float("1.234"))
+ and (s2fpar5 == 1.234))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar6 == str2float("1.0"))
+ and (s2fpar6 == 1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar7 == str2float("1" ))
+ and (s2fpar7 == 1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar7m== str2float("-1" ))
+ and (s2fpar7m==-1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar8m== str2float("-1." ))
+ and (s2fpar8m==-1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar8 == str2float("1." ))
+ and (s2fpar8 == 1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar9 == str2float("+001" )) //In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation `str2float\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation `str2float\(\)'//
+ and (s2fpar9 == 1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar10== str2float("+001.")) //In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation `str2float\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation `str2float\(\)'//
+ and (s2fpar10== 1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar11== str2float("-0" ))
+ and (s2fpar11==-0.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar12== str2float("-0." ))
+ and (s2fpar12== -0.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fpar13== str2float("-0.0" ))
+ and (s2fpar13== -0.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2fpar14 == str2float("infinity"))
+ and (s2fpar14 == infinity))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2fpar15 == str2float("-infinity"))
+ and (s2fpar15 == -infinity))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2fpar16 == str2float("not_a_number"))
+ and (s2fpar16 == not_a_number))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+// run-time
+ if ((s2fmp == str2float(s2fmp_str))
+ and (s2fmp == 0.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp1 == str2float(s2fmp1_str))
+ and (s2fmp1 == 12345678901.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp2 == str2float("000000000000" & "12345678901.0")) //In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation `str2float\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation `str2float\(\)'//
+ and (s2fmp2 == 12345678901.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp3 == str2float("-12" & "345678901.0"))
+ and (s2fmp3 == -12345678901.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp4 == str2float(s2fmp4_str))
+ and (s2fmp4 == 1234.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp5 == str2float(s2fmp5_str))
+ and (s2fmp5 == 1.234))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp6 == str2float(s2fmp6_str))
+ and (s2fmp6 == 1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp7 == str2float(s2fmp7_str))
+ and (s2fmp7 == 1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp7m == str2float(s2fmp7m_str))
+ and (s2fmp7m ==-1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp8m == str2float(s2fmp8m_str))
+ and (s2fmp8m ==-1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp8 == str2float(s2fmp8_str))
+ and (s2fmp8 == 1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp9 == str2float(s2fmp9_str))
+ and (s2fmp9 == 1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp10 == str2float(s2fmp10_str))
+ and (s2fmp10 == 1.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp11 == str2float(s2fmp11_str))
+ and (s2fmp11 ==-0.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp12 == str2float(s2fmp12_str))
+ and (s2fmp12 == -0.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2fmp13 == str2float(s2fmp13_str))
+ and (s2fmp13 == -0.0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2fmp14 == str2float(s2fmp14_str))
+ and (s2fmp14 == infinity))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2fmp15 == str2float(s2fmp15_str))
+ and (s2fmp15 == -infinity))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2fmp16 == str2float(s2fmp16_str))
+ and (s2fmp16 == not_a_number))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+}
+
+
+/*--- STR2HEX --------------------------------------------------*/
+
+const hexstring s2hcon := str2hex("")
+modulepar hexstring s2hpar := s2hcon
+modulepar hexstring s2hpar1 := str2hex("000000" & "" & "111111")
+const hexstring s2hcon2 := str2hex(substr("000000111111",0,6) & "" & substr("000000111111",6,6))
+modulepar hexstring s2hpar2 := s2hcon2
+modulepar hexstring s2hpar3 := str2hex(("000000" <@ lengthof(s2hcon2)/2) & "" & ("111111" @> lengthof(s2hcon2)/2))
+
+testcase str_to_hex() runs on PDTestComponent{
+
+
+ if ((s2hpar == str2hex(""))
+ and (s2hpar == ''H))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2hpar1 == str2hex("000000" & "" & "111111"))
+ and (s2hpar1 == '000000111111'H))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2hpar2 == str2hex(substr("000000111111",0,6) & "" & substr("000000111111",6,6)))
+ and (s2hpar2 == '000000111111'H))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2hpar3 == str2hex(("000000" <@ lengthof(s2hpar2)/2) & "" & ("111111" @> lengthof(s2hpar2)/2)))
+ and (s2hpar3 == '000000111111'H))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+
+ var integer j
+ var charstring cc := ""
+ var hexstring hh := ''H
+
+ for (j:=0; j<32; j:=j+1) {
+ cc := cc & hex2str(int2hex(j,j))
+ hh := hh & int2hex(j,j)
+ if (hh == str2hex(cc))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ }
+
+}
+
+/*--- STR2INT --------------------------------------------------*/
+
+const integer s2icon := str2int("0")
+modulepar integer s2ipar := s2icon
+modulepar integer s2ipar1 := str2int("" & "1234567890")
+modulepar integer s2ipar2 := str2int("12" & "34567890")
+modulepar integer s2ipar3 := str2int("0000000000000000000000" & "1234567890") //In module parameter definition// \
+ //In default value// //In the operand of operation `str2int\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the operand of operation `str2int\(\)'//
+modulepar integer s2ipar4 := str2int("-12" & "34567890")
+//modulepar integer s2ipar5 := str2int("12ap")
+modulepar integer s2ipar5 := str2int("12")
+//modulepar integer s2ipar6 := str2int("ap")
+modulepar integer s2ipar6 := str2int("1234567891011121314151617181920")
+modulepar integer s2ipar7 := str2int("-1234567891011121314151617181920")
+modulepar integer s2ipar8 := str2int("+1");
+modulepar integer s2ipar9 := str2int("01"); //In module parameter definition// \
+ //In default value// //In the operand of operation `str2int\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the operand of operation `str2int\(\)'//
+modulepar integer s2ipar10 := str2int("+01"); //In module parameter definition// \
+ //In default value// //In the operand of operation `str2int\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the operand of operation `str2int\(\)'//
+modulepar integer s2ipar11 := str2int("-01"); //In module parameter definition// \
+ //In default value// //In the operand of operation `str2int\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the operand of operation `str2int\(\)'//
+
+testcase str_to_int() runs on PDTestComponent{ //In testcase definition//
+ var charstring vv := "1234567891011121314151617181920"
+ var charstring vv1 := "-1234567891011121314151617181920"
+ var integer ii := str2int("1234567891011121314151617181920")
+ var integer ii1 := str2int("-1234567891011121314151617181920")
+
+ if ((s2ipar == str2int("0"))
+ and (s2ipar == 0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2ipar8 == str2int("+1"))
+ and (s2ipar8 == 1))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2ipar9 == str2int("01")) //In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation `str2int\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the operand of operation `str2int\(\)'//
+ and (s2ipar9 == 1))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2ipar10 == str2int("+01")) //In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation `str2int\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the operand of operation `str2int\(\)'//
+ and (s2ipar10 == 1))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2ipar11 == str2int("-01")) //In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation `str2int\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the operand of operation `str2int\(\)'//
+ and (s2ipar11 == -1))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2ipar1 == str2int("" & "1234567890"))
+ and (s2ipar1 == 1234567890))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2ipar2 == str2int("12" & "34567890"))
+ and (s2ipar2 == 1234567890))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2ipar3 == str2int("00000000000000000000000" & "1234567890")) //In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation `str2int\(\)'// \
+ //warning: Leading zero digit was detected and ignored in the operand of operation `str2int\(\)'//
+ and (s2ipar3 == 1234567890))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2ipar4 == str2int("-12" & "34567890"))
+ and (s2ipar4 == -1234567890))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((s2ipar5 == str2int("12"))
+ and (s2ipar5 == 12))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ /* Compiler error:
+ if ((s2ipar6 == str2int("ap"))
+ and (s2ipar6 == 0))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ */
+ // Compile time evaluation. (Positive/negative.)
+ if ((str2int("1234567891011121314151617181920") == s2ipar6)
+ and (s2ipar6 == str2int("1234567891011121314151617181920")))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((str2int("-1234567891011121314151617181920") == s2ipar7)
+ and (s2ipar7 == str2int("-1234567891011121314151617181920")))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ /* compile-time
+ if ((int2str(str2int("1234567891011121314151617181920")) == "1234567891011121314151617181920")
+ and ("1234567891011121314151617181920" == int2str(str2int("1234567891011121314151617181920"))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((int2str(str2int("-1234567891011121314151617181920")) == "-1234567891011121314151617181920")
+ and ("-1234567891011121314151617181920" == int2str(str2int("-1234567891011121314151617181920"))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ */
+ if ((str2int("1234567891011121314151617181920") - 10 == s2ipar6 - 10)
+ and (s2ipar6 + 10 == str2int("1234567891011121314151617181920") + 10))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((str2int("-1234567891011121314151617181920") + 10 == s2ipar7 + 10)
+ and (s2ipar7 - 10 == str2int("-1234567891011121314151617181920") - 10))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ // Run-time evaluation. (Positive/negative.)
+ if ((str2int(vv) == ii)
+ and (ii == str2int("1234567891011121314151617181920")))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((str2int("-1234567891011121314151617181920") == ii1)
+ and (ii1 == str2int(vv1)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((int2str(str2int(vv)) == "1234567891011121314151617181920")
+ and ("1234567891011121314151617181920" == int2str(str2int(vv))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((int2str(str2int(vv1)) == "-1234567891011121314151617181920")
+ and ("-1234567891011121314151617181920" == int2str(str2int(vv1))))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((str2int(vv) - 10 == ii - 10)
+ and (ii + 10 == str2int("1234567891011121314151617181920") + 10))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((str2int("-1234567891011121314151617181920") + 10 == ii1 + 10)
+ and (ii1 - 10 == str2int(vv1) - 10))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ if ((str2int(vv) == -str2int(vv1))
+ and (str2int(vv1) == -str2int(vv)))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ var integer j
+ for (j:=1; j<10; j:=j+1) {
+ if (str2int(substr("0123456789",0,j+1)) == (str2int(substr("0123456789",0,j))*10 + j))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ }
+}
+
+
+/*--- STR2OCT --------------------------------------------------*/
+
+const octetstring s2ocon := str2oct("")
+modulepar octetstring s2opar := s2ocon
+modulepar octetstring s2opar1 := str2oct("000000" & "" & "111111")
+const octetstring s2ocon2 := str2oct(substr("000000111111",0,6) & "" & substr("000000111111",6,6))
+modulepar octetstring s2opar2 := s2ocon2
+modulepar octetstring s2opar3 := str2oct(("000000" <@ lengthof(s2ocon2)/2) & "" & ("111111" @> lengthof(s2ocon2)/2))
+
+testcase str_to_oct() runs on PDTestComponent{
+
+
+ if ((s2opar == str2oct(""))
+ and (s2opar == ''O))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2opar1 == str2oct("000000" & "" & "111111"))
+ and (s2opar1 == '000000111111'O))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2opar2 == str2oct(substr("000000111111",0,6) & "" & substr("000000111111",6,6)))
+ and (s2opar2 == '000000111111'O))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+ if ((s2opar3 == str2oct(("000000" <@ lengthof(s2opar2)/2) & "" & ("111111" @> lengthof(s2opar2)/2)))
+ and (s2opar3 == '000000111111'O))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+
+
+ var integer j
+ var charstring cc := ""
+ var octetstring oo := ''O
+
+ for (j:=0; j<64; j:=j+1) {
+ cc := cc & oct2str(int2oct(j,j))
+ oo := oo & int2oct(j,j)
+ if (oo == str2oct(cc))
+ {setverdict(pass);}
+ else {setverdict(fail, __LINE__);}
+ }
+
+}
+
+
+control {
+ execute (str_to_bit());
+ execute (str_to_float());
+ execute (str_to_hex());
+ execute (str_to_int());
+ execute (str_to_oct());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/str_to_SW.ttcn b/Regression_Test_java/src/predefFunctions/str_to_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..99864813991c6ba402dba2a13fb46cf71545a152
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/str_to_SW.ttcn
@@ -0,0 +1,402 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module str_to_SW { //^In TTCN-3 module `str_to_SW'://
+
+type component PDTestComponent {};
+
+
+/*--- STR2BIT --------------------------------------------------*/
+
+const bitstring s2bcon := str2bit("")
+const bitstring s2bcon1 := str2bit("000000" & "" & "111111")
+const bitstring s2bcon2 := str2bit(substr("000000111111",0,6) & "" & substr("000000111111",6,6))
+const bitstring s2bcon3 := str2bit(("000000" <@ lengthof(s2bcon2)/2) & "" & ("111111" @> lengthof(s2bcon2)/2))
+
+testcase str_to_bit() runs on PDTestComponent{ //In testcase definition//
+
+
+ if ((s2bcon == str2bit(""))
+ and (s2bcon == ''B))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((s2bcon1 == str2bit("000000" & "" & "111111"))
+ and (s2bcon1 == '000000111111'B))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((s2bcon2 == str2bit(substr("000000111111",0,6) & "" & substr("000000111111",6,6)))
+ and (s2bcon2 == '000000111111'B))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((s2bcon3 == str2bit(("000000" <@ lengthof(s2bcon2)/2) & "" & ("111111" @> lengthof(s2bcon2)/2)))
+ and (s2bcon3 == '000000111111'B))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- STR2FLOAT --------------------------------------------------*/
+
+//const float s2fcon := str2float("")
+const float s2fcon := str2float("0.0")
+const float s2fcon1 := str2float("12345678901.0")
+const float s2fcon2 := str2float("000000000000" & "12345678901.0") //^In constant definition// \
+ //^In the operand of operation `str2float\(\)'// \
+ //^warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation \`str2float\(\)\'//
+const float s2fcon3 := str2float("-12" & "345678901.0")
+const float s2fcon4 := str2float("1.234E3")
+//const float s2fcon5 := str2float("1.234-3")
+const float s2fcon5 := str2float("1.234")
+//const float s2fcon6 := str2float("1,234E3")
+const float s2fcon6 := str2float("1.0")
+//const float s2fcon7 := str2float("--234")
+
+// HL67862
+const float s2fcon7 := str2float("1");
+const float s2fcon7m:= str2float("-1");
+const float s2fcon8m:= str2float("-1.");
+const float s2fcon8 := str2float("1.");
+const float s2fcon9 := str2float("+001"); //^In constant definition// \
+ //^In the operand of operation `str2float\(\)'// \
+ //^warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation \`str2float\(\)\'//
+const float s2fcon10:= str2float("+001."); //^In constant definition// \
+ //^In the operand of operation `str2float\(\)'// \
+ //^warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation \`str2float\(\)\'//
+const float s2fcon11:= str2float("-0");
+const float s2fcon12:= str2float("-0.");
+const float s2fcon13:= str2float("-0.0");
+
+const float s2fcon14:= str2float("infinity");
+const float s2fcon15:= str2float("-infinity");
+const float s2fcon16:= str2float("not_a_number");
+
+
+
+
+testcase str_to_float() runs on PDTestComponent{ //In testcase definition//
+ if ((s2fcon == str2float("0.0"))
+ and (s2fcon == 0.0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon1 == str2float("12345678901.0"))
+ and (s2fcon1 == 12345678901.0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon2 == str2float("000000000000" & "12345678901.0")) //^In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation \`str2float\(\)\'// \
+ //^warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation `str2float\(\)'//
+ and (s2fcon2 == 12345678901.0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon3 == str2float("-12" & "345678901.0"))
+ and (s2fcon3 == -12345678901.0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon4 == str2float("1.234E3"))
+ and (s2fcon4 == 1234.0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon5 == str2float("1.234"))
+ and (s2fcon5 == 1.234))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon6 == str2float("1.0"))
+ and (s2fcon6 == 1.0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((s2fcon7 == str2float("1" )) and (s2fcon7 == 1.0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon7m== str2float("-1" )) and (s2fcon7m==-1.0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon8m== str2float("-1." )) and (s2fcon8m==-1.0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon8 == str2float("1." )) and (s2fcon8 == 1.0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon9 == str2float("+001" )) and (s2fcon9 == 1.0)) //^In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation \`str2float\(\)\'// \
+ //^warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation `str2float\(\)'//
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon10== str2float("+001.")) and (s2fcon10== 1.0)) //^In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation \`str2float\(\)\'// \
+ //^warning: Leading zero digit was detected and ignored in the mantissa of the operand of operation `str2float\(\)'//
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon11== str2float("-0" )) and (s2fcon11== -0.0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon12== str2float("-0." )) and (s2fcon12== -0.0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon13== str2float("-0.0" )) and (s2fcon13== -0.0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon14== str2float("infinity")) and (s2fcon14== infinity))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon15== str2float("-infinity")) and (s2fcon15== -infinity))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2fcon16== str2float("not_a_number" )) and (s2fcon16== not_a_number))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+
+/*--- STR2HEX --------------------------------------------------*/
+
+const hexstring s2hcon := str2hex("")
+const hexstring s2hcon1 := str2hex("000000" & "" & "111111")
+const hexstring s2hcon2 := str2hex(substr("000000111111",0,6) & "" & substr("000000111111",6,6))
+const hexstring s2hcon3 := str2hex(("000000" <@ lengthof(s2hcon2)/2) & "" & ("111111" @> lengthof(s2hcon2)/2))
+
+testcase str_to_hex() runs on PDTestComponent{ //In testcase definition//
+
+
+ if ((s2hcon == str2hex(""))
+ and (s2hcon == ''H))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((s2hcon1 == str2hex("000000" & "" & "111111"))
+ and (s2hcon1 == '000000111111'H))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((s2hcon2 == str2hex(substr("000000111111",0,6) & "" & substr("000000111111",6,6)))
+ and (s2hcon2 == '000000111111'H))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((s2hcon3 == str2hex(("000000" <@ lengthof(s2hcon2)/2) & "" & ("111111" @> lengthof(s2hcon2)/2)))
+ and (s2hcon3 == '000000111111'H))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+/*--- STR2INT --------------------------------------------------*/
+
+const integer s2icon := str2int("0")
+const integer s2icon1 := str2int("" & "1234567890")
+const integer s2icon2 := str2int("12" & "34567890")
+const integer s2icon3 := str2int("0000000000000000000000" & "1234567890") //^In constant definition// \
+ //^In the operand of operation `str2int\(\)'// \
+ //^warning: Leading zero digit was detected and ignored in the operand of operation \`str2int\(\)\'//
+const integer s2icon4 := str2int("-12" & "34567890")
+//const integer s2icon5 := str2int("12ap")
+const integer s2icon5 := str2int("12")
+//const integer s2icon6 := str2int("ap")
+const integer s2icon6 := str2int("1234567891011121314151617181920")
+const integer s2icon7 := str2int("-1234567891011121314151617181920")
+const integer s2icon8 := str2int("+1");
+const integer s2icon9 := str2int("01"); //^In constant definition// \
+ //^In the operand of operation `str2int\(\)'// \
+ //^warning: Leading zero digit was detected and ignored in the operand of operation \`str2int\(\)\'//
+const integer s2icon10 := str2int("+01"); //^In constant definition// \
+ //^In the operand of operation `str2int\(\)'// \
+ //^warning: Leading zero digit was detected and ignored in the operand of operation \`str2int\(\)\'//
+const integer s2icon11 := str2int("-01"); //^In constant definition// \
+ //^In the operand of operation `str2int\(\)'// \
+ //^warning: Leading zero digit was detected and ignored in the operand of operation \`str2int\(\)\'//
+
+testcase str_to_int() runs on PDTestComponent{ //In testcase definition//
+ if ((s2icon == str2int("0"))
+ and (s2icon == 0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2icon8 == str2int("+1"))
+ and (s2icon8 == 1))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2icon9 == str2int("01")) //^In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation \`str2int\(\)\'// \
+ //^warning: Leading zero digit was detected and ignored in the operand of operation `str2int\(\)'//
+ and (s2icon9 == 1))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2icon10 == str2int("+01")) //^In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation \`str2int\(\)\'// \
+ //^warning: Leading zero digit was detected and ignored in the operand of operation `str2int\(\)'//
+ and (s2icon10 == 1))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2icon11 == str2int("-01")) //^In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation \`str2int\(\)\'// \
+ //^warning: Leading zero digit was detected and ignored in the operand of operation `str2int\(\)'//
+ and (s2icon11 == -1))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2icon1 == str2int("" & "1234567890"))
+ and (s2icon1 == 1234567890))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2icon2 == str2int("12" & "34567890"))
+ and (s2icon2 == 1234567890))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2icon3 == str2int("00000000000000000000000" & "1234567890")) //^In if statement// \
+ //In the left operand of operation `and'// \
+ //In the right operand of operation `=='// \
+ //In the operand of operation \`str2int\(\)\'// \
+ //^warning: Leading zero digit was detected and ignored in the operand of operation `str2int\(\)'//
+ and (s2icon3 == 1234567890))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2icon4 == str2int("-12" & "34567890"))
+ and (s2icon4 == -1234567890))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((s2icon5 == str2int("12"))
+ and (s2icon5 == 12))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ /* TODO move to error ttcn
+ if ((s2icon6 == str2int("ap"))
+ and (s2icon6 == 0))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);}
+ */
+ // Compile time evaluation. (Positive/negative.)
+ if ((str2int("1234567891011121314151617181920") == s2icon6)
+ and (s2icon6 == str2int("1234567891011121314151617181920")))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((str2int("-1234567891011121314151617181920") == s2icon7)
+ and (s2icon7 == str2int("-1234567891011121314151617181920")))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((int2str(str2int("1234567891011121314151617181920")) == "1234567891011121314151617181920")
+ and ("1234567891011121314151617181920" == int2str(str2int("1234567891011121314151617181920"))))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((int2str(str2int("-1234567891011121314151617181920")) == "-1234567891011121314151617181920")
+ and ("-1234567891011121314151617181920" == int2str(str2int("-1234567891011121314151617181920"))))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((str2int("1234567891011121314151617181920") - 10 == s2icon6 - 10)
+ and (s2icon6 + 10 == str2int("1234567891011121314151617181920") + 10))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((str2int("-1234567891011121314151617181920") + 10 == s2icon7 + 10)
+ and (s2icon7 - 10 == str2int("-1234567891011121314151617181920") - 10))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+
+/*--- STR2OCT --------------------------------------------------*/
+
+const octetstring s2ocon := str2oct("")
+const octetstring s2ocon1 := str2oct("000000" & "" & "111111")
+const octetstring s2ocon2 := str2oct(substr("000000111111",0,6) & "" & substr("000000111111",6,6))
+const octetstring s2ocon3 := str2oct(("000000" <@ lengthof(s2ocon2)/2) & "" & ("111111" @> lengthof(s2ocon2)/2))
+
+testcase str_to_oct() runs on PDTestComponent{ //In testcase definition//
+
+
+ if ((s2ocon == str2oct(""))
+ and (s2ocon == ''O))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((s2ocon1 == str2oct("000000" & "" & "111111"))
+ and (s2ocon1 == '000000111111'O))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((s2ocon2 == str2oct(substr("000000111111",0,6) & "" & substr("000000111111",6,6)))
+ and (s2ocon2 == '000000111111'O))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+ if ((s2ocon3 == str2oct(("000000" <@ lengthof(s2ocon2)/2) & "" & ("111111" @> lengthof(s2ocon2)/2)))
+ and (s2ocon3 == '000000111111'O))
+ {setverdict(pass);}
+ else {setverdict(fail,__LINE__);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+
+control {
+ execute (str_to_bit());
+ execute (str_to_float());
+ execute (str_to_hex());
+ execute (str_to_int());
+ execute (str_to_oct());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/sub_str_OK.ttcn b/Regression_Test_java/src/predefFunctions/sub_str_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..b7a73d19a170648eb7a737d85186f40682a8f9d4
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/sub_str_OK.ttcn
@@ -0,0 +1,284 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module sub_str_OK {
+
+type component PDTestComponent {};
+
+/*--- SUBSTR ON BITSTRING --------------------------------------------------*/
+
+const bitstring subb := '1110001100'B
+modulepar bitstring subb1 := substr('1110001100'B, 0, lengthof('1110001100'B)) // '1110001100'B
+const bitstring subb2c:= substr(subb, 5, 0) // ''B
+modulepar bitstring subb2 :=subb2c
+modulepar bitstring subb3 := substr(subb, 5, 5) // '01100'B
+modulepar bitstring subb4 := substr(subb, 0, 5) // '11100'B
+modulepar bitstring subb5 := substr(subb, 0, lengthof(subb)/2) // '11100'B
+modulepar bitstring subb6 := substr(subb2c, 0, lengthof(subb2c)) // ''B
+
+testcase substr_bitstr() runs on PDTestComponent{
+
+ if ((subb1 == subb)
+ and (subb1 == substr(subb, 0, 10)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subb2 == ''B)
+ and (subb2 == substr(subb, 5, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subb3 == '01100'B)
+ and (subb3 == substr(subb, 5, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subb4 == '11100'B)
+ and (subb4 == substr(subb, 0, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subb5 == subb4)
+ and (subb5 == substr(subb, 0, lengthof(subb)/2)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subb6 == ''B)
+ and (subb6 == substr(subb2, 0, lengthof(subb2))))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+/*--- SUBSTR ON HEXSTRING --------------------------------------------------*/
+
+const hexstring subh := '1110001100'H
+modulepar hexstring subh1 := substr('1110001100'H, 0, 10) // '1110001100'H
+const hexstring subh2c:= substr(subh, 5, 0) // ''H
+modulepar hexstring subh2 := subh2c
+modulepar hexstring subh3 := substr(subh, 5, 5) // '01100'H
+modulepar hexstring subh4 := substr(subh, 0, 5) // '11100'H
+modulepar hexstring subh5 := substr(subh, 0, lengthof(subh)/2) // '11100'H
+modulepar hexstring subh6 := substr(subh2c, 0, lengthof(subh2c)) // ''H
+
+testcase substr_hexstr() runs on PDTestComponent{
+
+ if ((subh1 == subh)
+ and (subh1 == substr(subh, 0, 10)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subh2 == ''H)
+ and (subh2 == substr(subh, 5, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subh3 == '01100'H)
+ and (subh3 == substr(subh, 5, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subh4 == '11100'H)
+ and (subh4 == substr(subh, 0, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subh5 == subh4)
+ and (subh5 == substr(subh, 0, lengthof(subh)/2)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subh6 == ''H)
+ and (subh6 == substr(subh2, 0, lengthof(subh2))))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+
+/*--- SUBSTR ON OCTETSTRING --------------------------------------------------*/
+
+const octetstring subo := '11111100000011110000'O
+modulepar octetstring subo1 := substr('11111100000011110000'O, 0, 10) // '11111100000011110000'O
+const octetstring subo2c:= substr(subo, 5, 0) // ''O
+modulepar octetstring subo2 := subo2c
+modulepar octetstring subo3 := substr(subo, 5, 5) // '0011110000'O
+modulepar octetstring subo4 := substr(subo, 0, 5) // '1111110000'O
+modulepar octetstring subo5 := substr(subo, 0, lengthof(subo)/2) // '1111110000'O
+modulepar octetstring subo6 := substr(subo2c, 0, lengthof(subo2c)) // ''O
+
+testcase substr_octetstr() runs on PDTestComponent{
+
+ if ((subo1 == subo)
+ and (subo1 == substr(subo, 0, 10)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subo2 == ''O)
+ and (subo2 == substr(subo, 5, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subo3 == '0011110000'O)
+ and (subo3 == substr(subo, 5, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subo4 == '1111110000'O)
+ and (subo4 == substr(subo, 0, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subo5 == subo4)
+ and (subo5 == substr(subo, 0, lengthof(subo)/2)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subo6 == ''O)
+ and (subo6 == substr(subo2, 0, lengthof(subo2))))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+/*--- SUBSTR ON CHARSTRING --------------------------------------------------*/
+
+const charstring subc := "1110001100"
+modulepar charstring subc1 := substr("1110001100", 0, 10) // "1110001100"
+const charstring subc2c:= substr(subc, 5, 0) // ""
+modulepar charstring subc2 := subc2c
+modulepar charstring subc3 := substr(subc, 5, 5) // "01100"
+modulepar charstring subc4 := substr(subc, 0, 5) // "11100"
+modulepar charstring subc5 := substr(subc, 0, lengthof(subc)/2) // "11100"
+modulepar charstring subc6 := substr(subc2c, 0, lengthof(subc2c)) // ""
+
+testcase substr_charstr() runs on PDTestComponent{
+
+ if ((subc1 == subc)
+ and (subc1 == substr(subc, 0, 10)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subc2 == "")
+ and (subc2 == substr(subc, 5, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subc3 == "01100")
+ and (subc3 == substr(subc, 5, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subc4 == "11100")
+ and (subc4 == substr(subc, 0, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subc5 == subc4)
+ and (subc5 == substr(subc, 0, lengthof(subc)/2)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subc6 == "")
+ and (subc6 == substr(subc2, 0, lengthof(subc2))))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+
+/*--- SUBSTR ON UNIVERSAL CHARSTRING --------------------------------------------------*/
+
+const universal charstring subuc := "1111" & char(0,0,0,65) & "0000" & char(0,0,0,66)
+modulepar universal charstring subuc1 := substr("1111A0000B", 0, 10) // "1111A0000B"
+const universal charstring subuc2c:= substr(subuc, 5, 0) // ""
+modulepar universal charstring subuc2 := subuc2c
+modulepar universal charstring subuc3 := substr(subuc, 5, 5) // "0000B"
+modulepar universal charstring subuc4 := substr(subuc, 0, 5) // "1111A"
+modulepar universal charstring subuc5 := substr(subuc, 0, lengthof(subuc)/2) // "1111A"
+modulepar universal charstring subuc6 := substr(subuc2c, 0, lengthof(subuc2c)) // ""
+
+testcase substr_ucharstr() runs on PDTestComponent{
+
+log (subuc)
+
+ if ((subuc1 == subuc)
+ and (subuc1 == substr(subuc, 0, 10)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subuc2 == "")
+ and (subc2 == substr(subuc, 5, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subuc3 == "0000B")
+ and (subuc3 == substr(subuc, 5, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subuc4 == "1111A")
+ and (subuc4 == substr(subuc, 0, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subuc5 == subuc4)
+ and (subuc5 == substr(subuc, 0, lengthof(subuc)/2)))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ if ((subuc6 == "")
+ and (subuc6 == substr(subuc2, 0, lengthof(subuc2))))
+ {setverdict(pass);}
+ else {setverdict(fail);}
+
+}
+
+/*--- SUBSTR --------------------------------------------------*/
+
+const charstring subcc := "000000000011111111110000000000111111111100000000001111111111000000000011111111110000000000111111111100000000001111111111"
+const bitstring subbb := str2bit(subcc)
+const hexstring subhh := str2hex(subcc)
+const octetstring suboo := str2oct(subcc & "")
+
+testcase substr_runtime() runs on PDTestComponent{
+
+ var integer j,i
+
+ for (j:=1; j<= lengthof(subcc)/2; j:=j+1) {
+ if (lengthof(subcc) rem j == 0) {
+ var charstring cc := ""
+ for (i:=0; i< lengthof(subcc)/j; i:=i+1) { cc := cc & substr(subcc,i*j,j)}
+ if (cc == subcc)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+ }
+
+ for (j:=1; j<= lengthof(subbb)/2; j:=j+1) {
+ if (lengthof(subbb) rem j == 0) {
+ var bitstring bb := ''B
+ for (i:=0; i< lengthof(subbb)/j; i:=i+1) { bb := bb & substr(subbb,i*j,j)}
+ if (bb == subbb)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+ }
+
+ for (j:=1; j<= lengthof(subhh)/2; j:=j+1) {
+ if (lengthof(subhh) rem j == 0) {
+ var hexstring hh := ''H
+ for (i:=0; i< lengthof(subhh)/j; i:=i+1) {hh := hh & substr(subhh,i*j,j)}
+ if (hh == subhh)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+ }
+
+ for (j:=2; j<= lengthof(suboo)/2; j:=j+2) {
+ if (lengthof(suboo) rem j == 0) {
+ var octetstring oo := ''O
+ for (i:=0; i< lengthof(suboo)/j; i:=i+1) { oo := oo & substr(suboo,i*j,j)}
+ if (oo == suboo)
+ {setverdict(pass);}
+ else {setverdict(fail);}
+ }
+ }
+
+
+}
+
+control {
+ execute (substr_bitstr());
+ execute (substr_hexstr());
+ execute (substr_octetstr());
+ execute (substr_charstr());
+ execute (substr_ucharstr());
+ execute (substr_runtime());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/sub_str_SW.ttcn b/Regression_Test_java/src/predefFunctions/sub_str_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..d30aa761be49594e73a46bea8db00789e47b7560
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/sub_str_SW.ttcn
@@ -0,0 +1,257 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module sub_str_SW { //^In TTCN-3 module `sub_str_SW'://
+
+type component PDTestComponent {};
+
+/*--- SUBSTR ON BITSTRING --------------------------------------------------*/
+
+const bitstring subb := '1110001100'B
+const bitstring subb1 := substr('1110001100'B, 0, lengthof('1110001100'B)) // '1110001100'B
+const bitstring subb2 := substr(subb, 5, 0) // ''B
+const bitstring subb3 := substr(subb, 5, 5) // '01100'B
+const bitstring subb4 := substr(subb, 0, 5) // '11100'B
+const bitstring subb5 := substr(subb, 0, lengthof(subb)/2) // '11100'B
+const bitstring subb6 := substr(subb2, 0, lengthof(subb2)) // ''B
+
+testcase substr_bitstr() runs on PDTestComponent{ //In testcase definition//
+
+ if ((subb1 == subb)
+ and (subb1 == substr(subb, 0, 10)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subb2 == ''B)
+ and (subb2 == substr(subb, 5, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subb3 == '01100'B)
+ and (subb3 == substr(subb, 5, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subb4 == '11100'B)
+ and (subb4 == substr(subb, 0, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subb5 == subb4)
+ and (subb5 == substr(subb, 0, lengthof(subb)/2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subb6 == ''B)
+ and (subb6 == substr(subb2, 0, lengthof(subb2))))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+}
+
+/*--- SUBSTR ON HEXSTRING --------------------------------------------------*/
+
+const hexstring subh := '1110001100'H
+const hexstring subh1 := substr('1110001100'H, 0, 10) // '1110001100'H
+const hexstring subh2 := substr(subh, 5, 0) // ''H
+const hexstring subh3 := substr(subh, 5, 5) // '01100'H
+const hexstring subh4 := substr(subh, 0, 5) // '11100'H
+const hexstring subh5 := substr(subh, 0, lengthof(subh)/2) // '11100'H
+const hexstring subh6 := substr(subh2, 0, lengthof(subh2)) // ''H
+
+testcase substr_hexstr() runs on PDTestComponent{ //^In testcase definition//
+
+ if ((subh1 == subh)
+ and (subh1 == substr(subh, 0, 10)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subh2 == ''H)
+ and (subh2 == substr(subh, 5, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subh3 == '01100'H)
+ and (subh3 == substr(subh, 5, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subh4 == '11100'H)
+ and (subh4 == substr(subh, 0, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subh5 == subh4)
+ and (subh5 == substr(subh, 0, lengthof(subh)/2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subh6 == ''H)
+ and (subh6 == substr(subh2, 0, lengthof(subh2))))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+}
+
+
+/*--- SUBSTR ON OCTETSTRING --------------------------------------------------*/
+
+const octetstring subo := '11111100000011110000'O
+const octetstring subo1 := substr('11111100000011110000'O, 0, 10) // '11111100000011110000'O
+const octetstring subo2 := substr(subo, 5, 0) // ''O
+const octetstring subo3 := substr(subo, 5, 5) // '0011110000'O
+const octetstring subo4 := substr(subo, 0, 5) // '1111110000'O
+const octetstring subo5 := substr(subo, 0, lengthof(subo)/2) // '1111110000'O
+const octetstring subo6 := substr(subo2, 0, lengthof(subo2)) // ''O
+
+testcase substr_octetstr() runs on PDTestComponent{ //In testcase definition//
+
+ if ((subo1 == subo)
+ and (subo1 == substr(subo, 0, 10)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subo2 == ''O)
+ and (subo2 == substr(subo, 5, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subo3 == '0011110000'O)
+ and (subo3 == substr(subo, 5, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subo4 == '1111110000'O)
+ and (subo4 == substr(subo, 0, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subo5 == subo4)
+ and (subo5 == substr(subo, 0, lengthof(subo)/2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subo6 == ''O)
+ and (subo6 == substr(subo2, 0, lengthof(subo2))))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+}
+
+/*--- SUBSTR ON CHARSTRING --------------------------------------------------*/
+
+const charstring subc := "1110001100"
+const charstring subc1 := substr("1110001100", 0, 10) // "1110001100"
+const charstring subc2 := substr(subc, 5, 0) // ""
+const charstring subc3 := substr(subc, 5, 5) // "01100"
+const charstring subc4 := substr(subc, 0, 5) // "11100"
+const charstring subc5 := substr(subc, 0, lengthof(subc)/2) // "11100"
+const charstring subc6 := substr(subc2, 0, lengthof(subc2)) // ""
+
+testcase substr_charstr() runs on PDTestComponent{ //In testcase definition//
+
+ if ((subc1 == subc)
+ and (subc1 == substr(subc, 0, 10)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subc2 == "")
+ and (subc2 == substr(subc, 5, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subc3 == "01100")
+ and (subc3 == substr(subc, 5, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subc4 == "11100")
+ and (subc4 == substr(subc, 0, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subc5 == subc4)
+ and (subc5 == substr(subc, 0, lengthof(subc)/2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subc6 == "")
+ and (subc6 == substr(subc2, 0, lengthof(subc2))))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+}
+
+
+/*--- SUBSTR ON UNIVERSAL CHARSTRING --------------------------------------------------*/
+
+const universal charstring subuc := "1111" & char(0,0,0,65) & "0000" & char(0,0,0,66)
+const universal charstring subuc1 := substr("1111A0000B", 0, 10) // "1111A0000B"
+const universal charstring subuc2 := substr(subuc, 5, 0) // ""
+const universal charstring subuc3 := substr(subuc, 5, 5) // "0000B"
+const universal charstring subuc4 := substr(subuc, 0, 5) // "1111A"
+const universal charstring subuc5 := substr(subuc, 0, lengthof(subuc)/2) // "1111A"
+const universal charstring subuc6 := substr(subuc2, 0, lengthof(subuc2)) // ""
+
+testcase substr_ucharstr() runs on PDTestComponent{ //In testcase definition//
+
+log (subuc)
+
+ if ((subuc1 == subuc)
+ and (subuc1 == substr(subuc, 0, 10)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subuc2 == "")
+ and (subc2 == substr(subuc, 5, 0)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subuc3 == "0000B")
+ and (subuc3 == substr(subuc, 5, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subuc4 == "1111A")
+ and (subuc4 == substr(subuc, 0, 5)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subuc5 == subuc4)
+ and (subuc5 == substr(subuc, 0, lengthof(subuc)/2)))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+ if ((subuc6 == "")
+ and (subuc6 == substr(subuc2, 0, lengthof(subuc2))))
+ {setverdict(pass);}
+ else {setverdict(fail);} //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+
+}
+
+/*--- SUBSTR --------------------------------------------------*/
+
+
+control {
+ execute (substr_bitstr());
+ execute (substr_hexstr());
+ execute (substr_octetstr());
+ execute (substr_charstr());
+ execute (substr_ucharstr());
+}
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/tcname_OK.ttcn b/Regression_Test_java/src/predefFunctions/tcname_OK.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..360bcad3f0662d9c6d96eb7accebc5957fe3504c
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/tcname_OK.ttcn
@@ -0,0 +1,58 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module tcname_OK {
+
+type component PDTestComponent {};
+
+/* Tests for testcasename() function. */
+
+function testcasename_in_func() return charstring {
+ return testcasename()
+}
+
+function testcasename_in_func_runson() runs on PDTestComponent return charstring {
+ return testcasename()
+}
+
+modulepar charstring expected_tc_name := "testcasename_in_tc";
+
+testcase testcasename_in_tc() runs on PDTestComponent {
+ if ("testcasename_in_tc" == testcasename_in_func())
+ { setverdict(pass) }
+ else { setverdict(fail) }
+ // For simple cases these should be the same.
+ if (%testcaseId == testcasename_in_func())
+ { setverdict(pass) }
+ else { setverdict(fail) }
+ if (%testcaseId == testcasename_in_func_runson())
+ { setverdict(pass) }
+ else { setverdict(fail) }
+ if (testcasename() == expected_tc_name)
+ { setverdict(pass) }
+ else { setverdict(fail) }
+}
+
+// Empty string from the control part.
+testcase testcasename_from_control(in charstring p) runs on PDTestComponent {
+ if (p == "") { setverdict(pass) } else { setverdict(fail) }
+}
+
+control {
+ execute(testcasename_in_tc());
+ execute(testcasename_from_control(testcasename()));
+ // Call again outside testcase, but not directly from the control part.
+ execute(testcasename_from_control(testcasename_in_func()));
+}
+
+
+}
diff --git a/Regression_Test_java/src/predefFunctions/tcname_SW.ttcn b/Regression_Test_java/src/predefFunctions/tcname_SW.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..571ac0a05f3f1c93c932a73d142830eb68bbb919
--- /dev/null
+++ b/Regression_Test_java/src/predefFunctions/tcname_SW.ttcn
@@ -0,0 +1,57 @@
+/******************************************************************************
+ * 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
+ * Raduly, Csaba
+ *
+ ******************************************************************************/
+module tcname_SW { //^In TTCN-3 module `tcname_SW'://
+
+type component PDTestComponent {};
+
+/* Tests for testcasename() function. */
+
+function testcasename_in_func() return charstring {
+ return testcasename()
+}
+
+function testcasename_in_func_runson() runs on PDTestComponent return charstring {
+ return testcasename()
+}
+
+testcase testcasename_in_tc() runs on PDTestComponent { //In testcase definition//
+ if ("testcasename_in_tc" == testcasename_in_func())
+ { setverdict(pass) }
+ else { setverdict(fail) }
+ // For simple cases these should be the same.
+ if (%testcaseId == testcasename_in_func())
+ { setverdict(pass) }
+ else { setverdict(fail) }
+ if (%testcaseId == testcasename_in_func_runson())
+ { setverdict(pass) }
+ else { setverdict(fail) }
+ if (testcasename() == "testcasename_in_tc")
+ { setverdict(pass) }
+ else { setverdict(fail) } //^In else statement// \
+ //^warning\: Control never reaches this code because of previous effective condition\(s\)//
+}
+
+// Empty string from the control part.
+testcase testcasename_from_control(in charstring p) runs on PDTestComponent {
+ if (p == "") { setverdict(pass) } else { setverdict(fail) }
+}
+
+control {
+ execute(testcasename_in_tc());
+ execute(testcasename_from_control(testcasename()));
+ // Call again outside testcase, but not directly from the control part.
+ execute(testcasename_from_control(testcasename_in_func()));
+}
+
+
+}
diff --git a/Regression_Test_java/src/tryCatch_Functions.ttcn b/Regression_Test_java/src/tryCatch_Functions.ttcn
new file mode 100644
index 0000000000000000000000000000000000000000..320fea852d303a0dc2bbac96518752b01e9a152f
--- /dev/null
+++ b/Regression_Test_java/src/tryCatch_Functions.ttcn
@@ -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
+ *
+ ******************************************************************************/
+module tryCatch_Functions{
+
+function f_matchAndVerdict(in charstring pl_msg, in template charstring pl_template) {
+ if(match(pl_msg, pl_template))
+ { setverdict(pass) } else {setverdict(fail)};
+}
+
+}
diff --git a/Regression_Test_java/src2/org/eclipse/titan/Regression_Test_java/user_provided/package-info.java b/Regression_Test_java/src2/org/eclipse/titan/Regression_Test_java/user_provided/package-info.java
new file mode 100644
index 0000000000000000000000000000000000000000..8afef84b96ea8bfd45d4537ec1f0490c950ca0ae
--- /dev/null
+++ b/Regression_Test_java/src2/org/eclipse/titan/Regression_Test_java/user_provided/package-info.java
@@ -0,0 +1,14 @@
+// This Java file was generated by the TITAN Designer eclipse plug-in
+// of the TTCN-3 Test Executor version CRL 113 200/6 R5B
+// for (ekrisza@HU-00000227)
+
+// Copyright (c) 2000-2018 Ericsson Telecom AB
+
+/**
+ * <code>org.eclipse.titan.Regression_Test_java.user_provided</code> package contains classes
+ * that were written by the user, and contain the implementations of test ports and external functions.
+ *<p>
+ * Do not edit this file unless you know what you are doing!
+ */
+package org.eclipse.titan.Regression_Test_java.user_provided;
+