From 3d2c433f24d5932608ac96763f6f66dcb99425d0 Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Fri, 17 Feb 2023 11:05:26 +0100 Subject: [PATCH 01/14] Add tests for ??? --- ...0106_the_not_implemented_function_000.ttcn | 16 ++++++++++++ ...0106_the_not_implemented_function_001.ttcn | 16 ++++++++++++ ...0106_the_not_implemented_function_002.ttcn | 16 ++++++++++++ ...0106_the_not_implemented_function_003.ttcn | 18 +++++++++++++ ...0106_the_not_implemented_function_004.ttcn | 23 ++++++++++++++++ ...0106_the_not_implemented_function_005.ttcn | 16 ++++++++++++ ...0106_the_not_implemented_function_006.ttcn | 17 ++++++++++++ ...0106_the_not_implemented_function_007.ttcn | 16 ++++++++++++ ...0106_the_not_implemented_function_008.ttcn | 16 ++++++++++++ ...0106_the_not_implemented_function_001.ttcn | 23 ++++++++++++++++ ...0106_the_not_implemented_function_002.ttcn | 19 ++++++++++++++ ...0106_the_not_implemented_function_003.ttcn | 20 ++++++++++++++ ...0106_the_not_implemented_function_004.ttcn | 19 ++++++++++++++ ...0106_the_not_implemented_function_005.ttcn | 26 +++++++++++++++++++ 14 files changed, 261 insertions(+) create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_000.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_001.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_002.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_003.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_004.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_005.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_006.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_007.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_008.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_001.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_002.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_003.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_004.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_005.ttcn diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_000.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_000.ttcn new file mode 100644 index 0000000..08c57b4 --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_000.ttcn @@ -0,0 +1,16 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure optional parameter is universal charstring + // @verdict pass accept, ttcn3verdict:error +module NegSem_160106_the_not_implemented_function_000 { + +type component GeneralComp {} + +testcase TC_NegSem_160106_the_not_implemented_function_000() runs on GeneralComp { + ???("Hello " & ???); +} + +control { + execute(TC_NegSem_160106_the_not_implemented_function_000()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_001.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_001.ttcn new file mode 100644 index 0000000..f6dc2f4 --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_001.ttcn @@ -0,0 +1,16 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure ??? can be used as value in local expressions + // @verdict pass accept, ttcn3verdict:error +module NegSem_160106_the_not_implemented_function_001 { + +type component GeneralComp {} + +testcase TC_NegSem_160106_the_not_implemented_function_001() runs on GeneralComp { + var integer i := ???; +} + +control { + execute(TC_NegSem_160106_the_not_implemented_function_001()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_002.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_002.ttcn new file mode 100644 index 0000000..61f979e --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_002.ttcn @@ -0,0 +1,16 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure ??? can be used as value in any expressions + // @verdict pass accept, ttcn3verdict:error +module NegSem_160106_the_not_implemented_function_002 { + +type component GeneralComp {} + +testcase TC_NegSem_160106_the_not_implemented_function_002() runs on GeneralComp { + var integer i := -???; +} + +control { + execute(TC_NegSem_160106_the_not_implemented_function_002()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_003.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_003.ttcn new file mode 100644 index 0000000..bd49bc9 --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_003.ttcn @@ -0,0 +1,18 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure ??? can be used as value in module parameters + // @verdict pass accept, ttcn3verdict:error +module NegSem_160106_the_not_implemented_function_003 { + +modulepar charstring reason := ???; + +type component GeneralComp {} + +testcase TC_NegSem_160106_the_not_implemented_function_003() runs on GeneralComp { + setverdict(pass, reason); +} + +control { + execute(TC_NegSem_160106_the_not_implemented_function_003()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_004.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_004.ttcn new file mode 100644 index 0000000..233f6da --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_004.ttcn @@ -0,0 +1,23 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure ??? can be used as value as default parameter + // @verdict pass accept, ttcn3verdict:error +module NegSem_160106_the_not_implemented_function_004 { + +type component GeneralComp {} + +function isNeg(in integer i := ???) boolean { + return i < 0; +} + +testcase TC_NegSem_160106_the_not_implemented_function_004() runs on GeneralComp { + // Will have error verdict, because default parameter of isNeg contains ???. + if (isNeg()) { + setverdict(pass); + } +} + +control { + execute(TC_NegSem_160106_the_not_implemented_function_004()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_005.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_005.ttcn new file mode 100644 index 0000000..7e66e5c --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_005.ttcn @@ -0,0 +1,16 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure ??? can be used as stand-alone statement (direct use) + // @verdict pass accept, ttcn3verdict:error +module NegSem_160106_the_not_implemented_function_005 { + +type component GeneralComp {} + +testcase TC_NegSem_160106_the_not_implemented_function_005() runs on GeneralComp { + ??? +} + +control { + execute(TC_NegSem_160106_the_not_implemented_function_005()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_006.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_006.ttcn new file mode 100644 index 0000000..85054c6 --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_006.ttcn @@ -0,0 +1,17 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure optional parameter is universal charstring + // @verdict pass reject +module NegSem_160106_the_not_implemented_function_006 { + +type component GeneralComp {} + +testcase TC_NegSem_160106_the_not_implemented_function_006() runs on GeneralComp { + var integer i := 5; + ???(i); +} + +control { + execute(TC_NegSem_160106_the_not_implemented_function_006()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_007.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_007.ttcn new file mode 100644 index 0000000..c8cdb20 --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_007.ttcn @@ -0,0 +1,16 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure optional parameter is universal charstring + // @verdict pass accept, ttcn3verdict:error +module NegSem_160106_the_not_implemented_function_007 { + +type component GeneralComp {} + +testcase TC_NegSem_160106_the_not_implemented_function_007() runs on GeneralComp { + ???("charstring is compatible with universal charstring"); +} + +control { + execute(TC_NegSem_160106_the_not_implemented_function_007()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_008.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_008.ttcn new file mode 100644 index 0000000..d5af59f --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_008.ttcn @@ -0,0 +1,16 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure optional parameter is universal charstring + // @verdict pass accept, ttcn3verdict:error +module NegSem_160106_the_not_implemented_function_008 { + +type component GeneralComp {} + +testcase TC_NegSem_160106_the_not_implemented_function_008() runs on GeneralComp { + ???("Hello wörld!"); +} + +control { + execute(TC_NegSem_160106_the_not_implemented_function_008()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_001.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_001.ttcn new file mode 100644 index 0000000..d00081d --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_001.ttcn @@ -0,0 +1,23 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure ??? can be used as value as default parameter + // @verdict pass accept, ttcn3verdict:pass +module Sem_160106_the_not_implemented_function_001 { + +type component GeneralComp {} + +function isNeg(in integer i := ???) boolean { + return i < 0; +} + +testcase TC_Sem_160106_the_not_implemented_function_001() runs on GeneralComp { + // No error because default parameter is not evaluated. + if (isNeg(-5)) { + setverdict(pass); + } +} + +control { + execute(TC_Sem_160106_the_not_implemented_function_001()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_002.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_002.ttcn new file mode 100644 index 0000000..5e56ae8 --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_002.ttcn @@ -0,0 +1,19 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure ??? can be used as stand-alone statement (direct use) + // @verdict pass accept, ttcn3verdict:pass +module Sem_160106_the_not_implemented_function_002 { + +type component GeneralComp {} + +testcase TC_Sem_160106_the_not_implemented_function_002() runs on GeneralComp { + if (false) { + ??? + } + setverdict(pass); +} + +control { + execute(TC_Sem_160106_the_not_implemented_function_002()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_003.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_003.ttcn new file mode 100644 index 0000000..cf92f21 --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_003.ttcn @@ -0,0 +1,20 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure ??? allows optional parameter + // @verdict pass accept, ttcn3verdict:pass +module Sem_160106_the_not_implemented_function_003 { + +type component GeneralComp {} + +testcase TC_Sem_160106_the_not_implemented_function_003() runs on GeneralComp { + if (false) { + var universal charstring s := "abc"; + ???(s); + } + setverdict(pass); +} + +control { + execute(TC_Sem_160106_the_not_implemented_function_003()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_004.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_004.ttcn new file mode 100644 index 0000000..d922547 --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_004.ttcn @@ -0,0 +1,19 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure optional parameter is universal charstring + // @verdict pass accept, ttcn3verdict:pass +module Sem_160106_the_not_implemented_function_004 { + +type component GeneralComp {} + +testcase TC_Sem_160106_the_not_implemented_function_004() runs on GeneralComp { + if (false) { + ???("Hello " & ???); + } + setverdict(pass); +} + +control { + execute(TC_Sem_160106_the_not_implemented_function_004()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_005.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_005.ttcn new file mode 100644 index 0000000..94d50cc --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_005.ttcn @@ -0,0 +1,26 @@ + // @author TTF23 + // @purpose 1:16.1.6, Ensure implementation does not change during tests execution + // @verdict pass accept, ttcn3verdict:pass +module Sem_160106_the_not_implemented_function_005 { + +type component GeneralComp {} + +function @deterministic f() return charstring { + return ???; +} + +testcase TC_Sem_160106_the_not_implemented_function_005() runs on GeneralComp { + var charstring x := f(); + var charstring y := f(); + if (x == y) { + setverdict(pass); + } else { + setverdict(fail, x & " != " & y); + } +} + +control { + execute(TC_Sem_160106_the_not_implemented_function_005()); +} + +} -- GitLab From 63a7566c4db06399610d97864ad939bb27366ab2 Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Fri, 17 Feb 2023 15:35:11 +0100 Subject: [PATCH 02/14] Add tests for variadic functions --- ...NegSem_050403_variadic_parameters_001.ttcn | 8 ++++ ...NegSem_050403_variadic_parameters_002.ttcn | 8 ++++ ...NegSem_050403_variadic_parameters_003.ttcn | 9 +++++ ...NegSem_050403_variadic_parameters_004.ttcn | 21 ++++++++++ ...NegSem_050403_variadic_parameters_005.ttcn | 18 +++++++++ .../Sem_050403_variadic_parameters_001.ttcn | 10 +++++ .../Sem_050403_variadic_parameters_002.ttcn | 8 ++++ .../Sem_050403_variadic_parameters_003.ttcn | 8 ++++ .../Sem_050403_variadic_parameters_004.ttcn | 16 ++++++++ .../Sem_050403_variadic_parameters_005.ttcn | 8 ++++ .../Sem_050403_variadic_parameters_006.ttcn | 16 ++++++++ .../Sem_050403_variadic_parameters_007.ttcn | 23 +++++++++++ .../Sem_050403_variadic_parameters_008.ttcn | 24 ++++++++++++ .../Sem_050403_variadic_parameters_009.ttcn | 38 +++++++++++++++++++ .../Sem_050403_variadic_parameters_010.ttcn | 38 +++++++++++++++++++ .../Sem_050403_variadic_parameters_011.ttcn | 24 ++++++++++++ 16 files changed, 277 insertions(+) create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_001.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_002.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_003.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_004.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_005.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_001.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_002.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_003.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_004.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_005.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_006.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_007.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_008.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_009.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_010.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_011.ttcn diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_001.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_001.ttcn new file mode 100644 index 0000000..52ec0f9 --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_001.ttcn @@ -0,0 +1,8 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure variadic formal parameters are at the end of the formal parameter list. + // @verdict pass reject +module NegSem_050403_variadic_parameters_001 { + + function f(in integer i..., in integer max) {} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_002.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_002.ttcn new file mode 100644 index 0000000..269bc28 --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_002.ttcn @@ -0,0 +1,8 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure only one variadic formal parameter per formal parameter list is allowed. + // @verdict pass reject +module NegSem_050403_variadic_parameters_002 { + +function f(in integer a..., in integer b...) {} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_003.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_003.ttcn new file mode 100644 index 0000000..469d32d --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_003.ttcn @@ -0,0 +1,9 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure variadic parameters are in parameters. + // @verdict pass reject +module NegSem_050403_variadic_parameters_003 { + +function f1(inout integer x...) {} +function f2(out integer x...) {} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_004.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_004.ttcn new file mode 100644 index 0000000..2868e67 --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_004.ttcn @@ -0,0 +1,21 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure actual variadic parameter results in an equivalent record of in their declaration order. + // @verdict pass reject +module NegSem_050403_variadic_parameters_004 { + +type record of integer RoI; +type component GeneralComp {} + +function f(in integers... args) return RoI { + return args +} + +testcase TC_NegSem_050403_variadic_parameters_004() runs on GeneralComp { + f(-, -); // Reject: f() has only one variadic parameter to omit. +} + +control { + execute(TC_NegSem_050403_variadic_parameters_004()); +} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_005.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_005.ttcn new file mode 100644 index 0000000..13d8d9c --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_005.ttcn @@ -0,0 +1,18 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure an actual record of parameter in assignment notation has no additional ellipsis. + // @verdict pass reject +module NegSem_050403_variadic_parameters_005 { + +type component GeneralComp {} + +testcase TC_NegSem_050403_variadic_parameters_005() runs on GeneralComp { + f(args := {1,2,3}...); +} + +function f(in integer args...) {} + +control { + execute(TC_NegSem_050403_variadic_parameters_005()); +} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_001.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_001.ttcn new file mode 100644 index 0000000..4792ed5 --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_001.ttcn @@ -0,0 +1,10 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure template definitions support variadic formal parameters. + // @verdict pass accept +module Sem_050403_variadic_parameters_001 { + +type record of integer RoI; + +template Roi aRoi(in integer numbers...) := {} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_002.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_002.ttcn new file mode 100644 index 0000000..f139507 --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_002.ttcn @@ -0,0 +1,8 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure function definitions support variadic formal parameters. + // @verdict pass accept +module Sem_050403_variadic_parameters_002 { + +function f(in integer i...) {} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_003.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_003.ttcn new file mode 100644 index 0000000..bc196fb --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_003.ttcn @@ -0,0 +1,8 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure altstep definitions support variadic formal parameters. + // @verdict pass accept +module Sem_050403_variadic_parameters_003 { + +altstep as1(in integer items...) {} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_004.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_004.ttcn new file mode 100644 index 0000000..87a9914 --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_004.ttcn @@ -0,0 +1,16 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure testcase definitions support variadic formal parameters. + // @verdict pass accept, testverdict:pass +module Sem_050403_variadic_parameters_004 { + +type component GeneralComp {} + +testcase TC_Sem_050403_variadic_parameters_004(in verdicttype verdicts...) runs on GeneralComp { + setverdict(pass); +} + +control { + execute(TC_Sem_050403_variadic_parameters_004()); +} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_005.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_005.ttcn new file mode 100644 index 0000000..15383cc --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_005.ttcn @@ -0,0 +1,8 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure variadic formal parameters may have default values. + // @verdict pass accept +module Sem_050403_variadic_parameters_005 { + +function f(in integer i... := {1,2,3}) {} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_006.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_006.ttcn new file mode 100644 index 0000000..7582304 --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_006.ttcn @@ -0,0 +1,16 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure variadic parameters are visible as record of types inside the defintion. + // @verdict pass accept +module Sem_050403_variadic_parameters_006 { + + +type record of integer RoI; +type record of integer RoA[3]; +type record of C RoC; +type component C {} + +function f1(integer args...) { var RoI r := args } +function f2(integer args[3]...) { var RoA r := args } +function f3(C args[3]...) { var RoC r := args } + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_007.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_007.ttcn new file mode 100644 index 0000000..02abcc5 --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_007.ttcn @@ -0,0 +1,23 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure omitted variadic parameter results in an empty record of. + // @verdict pass accept, ttcn3verdict:pass +module Sem_050403_variadic_parameters_007 { + +type component GeneralComp {} + +testcase TC_Sem_050403_variadic_parameters_007() runs on GeneralComp { + + if (len() == 0) { + setverdict(pass); + } else { + setverdict(fail, "len() != 0"); + } +} + +function len(in integer args...) return integer { return lengthof(args) } + +control { + execute(TC_Sem_050403_variadic_parameters_007()); +} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_008.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_008.ttcn new file mode 100644 index 0000000..1d851fb --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_008.ttcn @@ -0,0 +1,24 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure unused variadic parameter results in an empty record of. + // @verdict pass accept, ttcn3verdict:pass +module Sem_050403_variadic_parameters_008 { + +type component GeneralComp {} + +testcase TC_Sem_050403_variadic_parameters_008() runs on GeneralComp { + + if (len(-) == 0) { + setverdict(pass); + } else { + setverdict(fail, "len() != 0"); + } + +} + +function len(in integer args...) return integer { return lengthof(args) } + +control { + execute(TC_Sem_050403_variadic_parameters_008()); +} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_009.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_009.ttcn new file mode 100644 index 0000000..070f6d2 --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_009.ttcn @@ -0,0 +1,38 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure actual variadic parameter results in an equivalent record of in their declaration order. + // @verdict pass accept, ttcn3verdict:pass +module Sem_050403_variadic_parameters_009 { + +type record of integer Roi; +type component GeneralComp {} + +function f(in integer args...) returns RoI { + return args +} + +testcase TC_Sem_050403_variadic_parameters_009() runs on GeneralComp { + if (f() == {}) { + setverdict(pass); + } else { + setverdict(fail, "f() != {}"); + } + + if (f(1) == {1}) { + setverdict(pass); + } else { + setverdict(fail, "f(1) != {1}"); + } + + if (f(1,2,3) == {1,2,3}) { + setverdict(pass); + } else { + setverdict(fail, "f(1,2,3) != {1,2,3}"); + } +} + + +control { + execute(TC_Sem_050403_variadic_parameters_009()); +} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_010.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_010.ttcn new file mode 100644 index 0000000..008e8fa --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_010.ttcn @@ -0,0 +1,38 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure an actual record of parameter with ... is passed directly to the formal variadic parameter. + // @verdict pass accept, ttcn3verdict:pass +module Sem_050403_variadic_parameters_010 { + +type record of integer RoI; +type component GeneralComp {} + +function len(in integer args...) return integer { + return lengthof(args); +} + +testcase TC_Sem_050403_variadic_parameters_010() runs on GeneralComp { + if (len({}...) == 0) { + setverdict(pass); + } else { + setverdict(fail, "len({}...) != 0"); + } + + if (len({1,2,3}...) == 3) { + setverdict(pass); + } else { + setverdict(fail, "len({1,2,3}...) != 3"); + } + + var RoI r := {1,2,3}; + if (len(r...) == 3) { + setverdict(pass); + } else { + setverdict(fail, "len(r...) != 3"); + } +} + +control { + execute(TC_Sem_050403_variadic_parameters_010()); +} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_011.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_011.ttcn new file mode 100644 index 0000000..ae16c38 --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_011.ttcn @@ -0,0 +1,24 @@ + // @author TTF23 + // @purpose 1:5.4.3, Ensure an actual record of parameter in assignment notation is passed directly to the formal variadic parameter. + // @verdict pass accept, ttcn3verdict:pass +module Sem_050403_variadic_parameters_011 { + +type component GeneralComp {} + +testcase TC_Sem_050403_variadic_parameters_011() runs on GeneralComp { + if (len(args := {1, 2, 3}) == 3)) { + setverdict(pass); + } else { + setverdict(fail, "len(args := {1, 2, 3}) != 3"); + } +} + +function len(in integer args...) return integer { + return lengthof(args); +} + +control { + execute(TC_Sem_050403_variadic_parameters_011()); +} + +} -- GitLab From f0c7b31bb99ae4141bfa27cc85387027cf3e0c95 Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Fri, 17 Feb 2023 15:37:27 +0100 Subject: [PATCH 03/14] Add alpine default image --- .gitlab-ci.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 20b8e2f..dda1b8e 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -3,8 +3,10 @@ stages: - package - deploy -before_script: - - apk add bash git +default: + image: alpine + before_script: + - apk add bash git # format-check verifies that our tests follow guide lines, are well named and # formatted. -- GitLab From 02a4c371845ad499c022c329da02672f17c6a4f7 Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Fri, 17 Feb 2023 17:08:30 +0100 Subject: [PATCH 04/14] Add tests for embedded fields --- .../NegSem_06020104_embedding_fields_001.ttcn | 17 ++++++++ .../NegSem_06020104_embedding_fields_002.ttcn | 23 ++++++++++ .../Sem_06020104_embedding_fields_001.ttcn | 28 +++++++++++++ .../Sem_06020104_embedding_fields_002.ttcn | 33 +++++++++++++++ .../Sem_06020104_embedding_fields_003.ttcn | 37 ++++++++++++++++ .../Sem_06020104_embedding_fields_004.ttcn | 38 +++++++++++++++++ .../Sem_06020204_embedding_fields_001.ttcn | 10 +++++ .../Sem_06020504_embedding_fields_001.ttcn | 42 +++++++++++++++++++ 8 files changed, 228 insertions(+) create mode 100644 ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_002.ttcn create mode 100644 ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_002.ttcn create mode 100644 ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_003.ttcn create mode 100644 ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_004.ttcn create mode 100644 ATS/core_language/06_types_and_values/0602_structured_types_and_values/060202_set_type_and_values/06020204_embedding_fields/Sem_06020204_embedding_fields_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0602_structured_types_and_values/060205_unions/06020504_embedding_fields/Sem_06020504_embedding_fields_001.ttcn diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_001.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_001.ttcn new file mode 100644 index 0000000..f501a8c --- /dev/null +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_001.ttcn @@ -0,0 +1,17 @@ + // @author TTF23 + // @purpose 1:6.2.1.4, Ensure the unqualified type name acts as the field name. + // @verdict pass reject +module NegSem_06020104_embedding_fields_001 { + +type record of integer RoI; +type union U { + record of integer RoI; +} + +// Reject nested or anonymous types. +type record R { + Roi[-] + U.Roi +} + +} diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_002.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_002.ttcn new file mode 100644 index 0000000..17b0a05 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_002.ttcn @@ -0,0 +1,23 @@ + // @author TTF23 + // @purpose 1:6.2.1.4, Ensure embedded fields cannot be used as field names for assignment notations. + // @verdict pass reject +module NegSem_06020104_embedding_fields_002 { + +type component GeneralComp {} + +type record A { + B +} + +type record B { + integer b +} + +const A OK := { B := { b := 1 } } +const A notOK := { b := 1 } + +control { + execute(TC_NegSem_06020104_embedding_fields_002()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_001.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_001.ttcn new file mode 100644 index 0000000..b17c537 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_001.ttcn @@ -0,0 +1,28 @@ + // @author TTF23 + // @purpose 1:6.2.1.4, Ensure the unqualified type name acts as the field name. + // @verdict pass accept +module Sem_06020104_embedding_fields_001 { + +type component GeneralComp {} + +type record R { + integer, + R optional, + Sem_06020104_embedding_fields_001.GeneralComp +} + + +testcase TC_Sem_06020104_embedding_fields_001() runs on GeneralComp { + var R r := { + integer := 23, + R := {} + } + r.GeneralComp := GeneralComp.create + setverdict(pass) +} + +control { + execute(TC_Sem_06020104_embedding_fields_001()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_002.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_002.ttcn new file mode 100644 index 0000000..a2678b3 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_002.ttcn @@ -0,0 +1,33 @@ + // @author TTF23 + // @purpose 1:6.2.1.4, Ensure embedded field is promoted when its name is unique. + // @verdict pass accept, ttcn3verdict:pass +module Sem_06020104_embedding_fields_002 { + +type component GeneralComp {} + +type record A { + B +} + +type record B { + integer b; +} + +testcase TC_Sem_06020104_embedding_fields_002() runs on GeneralComp { + var A a; + + a.b := 1; + a.B.b := 2; + + if (a.b == a.B.b) { + setverdict(pass); + } else { + setverdict(fail); + } +} + +control { + execute(TC_Sem_06020104_embedding_fields_002()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_003.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_003.ttcn new file mode 100644 index 0000000..8a77c31 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_003.ttcn @@ -0,0 +1,37 @@ + // @author TTF23 + // @purpose 1:6.2.1.4, Ensure embedded field is promoted when its name is unique. + // @verdict pass accept, ttcn3verdict:pass +module Sem_06020104_embedding_fields_003 { + +type component GeneralComp {} + +type record A { + B +} + +type record B { + C +} + +type record C { + integer c +} + +testcase TC_Sem_06020104_embedding_fields_003() runs on GeneralComp { + var A a; + + a.c := 1; + a.B.C.c := 2; + + if (a.c == a.B.C.c) { + setverdict(pass); + } else { + setverdict(fail, "field c not promoted"); + } +} + +control { + execute(TC_Sem_06020104_embedding_fields_003()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_004.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_004.ttcn new file mode 100644 index 0000000..01203e6 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_004.ttcn @@ -0,0 +1,38 @@ + // @author TTF23 + // @purpose 1:6.2.1.4, Ensure embedded field is not promoted when its name is not unique. + // @verdict pass accept, ttcn3verdict:pass +module Sem_06020104_embedding_fields_004 { + +type component GeneralComp {} + + +type record A { + B +} + +type record B { + C, + integer x +} + +type record C { + integer x +} + +testcase TC_Sem_06020104_embedding_fields_004() runs on GeneralComp { + var A a; + a.x := 1; + a.B.x := 2; + a.B.C.x := 3; + if (a.x == a.B.x and a.B.x != a.B.C.x) { + setverdict(pass); + } else { + setverdict(fail); + } +} + +control { + execute(TC_Sem_06020104_embedding_fields_004()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060202_set_type_and_values/06020204_embedding_fields/Sem_06020204_embedding_fields_001.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060202_set_type_and_values/06020204_embedding_fields/Sem_06020204_embedding_fields_001.ttcn new file mode 100644 index 0000000..6bb8a60 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060202_set_type_and_values/06020204_embedding_fields/Sem_06020204_embedding_fields_001.ttcn @@ -0,0 +1,10 @@ + // @author TTF23 + // @purpose 1:6.2.2.4, Ensure set defintion allow embedded fields + // @verdict pass accept +module Sem_06020204_embedding_fields_001 { + +type set S { + integer +} + +} diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060205_unions/06020504_embedding_fields/Sem_06020504_embedding_fields_001.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060205_unions/06020504_embedding_fields/Sem_06020504_embedding_fields_001.ttcn new file mode 100644 index 0000000..2f3a108 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060205_unions/06020504_embedding_fields/Sem_06020504_embedding_fields_001.ttcn @@ -0,0 +1,42 @@ + // @author TTF23 + // @purpose 1:6.2.5.4, Ensure union defintions allow embedded fields and handle promotion correctly. + // @verdict pass accept, ttcn3verdict:pass +module Sem_06020504_embedding_fields_001 { + +type component GeneralComp {} + +type union Anytype { + integer, + boolean, + R +} + +type record R { + integer, + verdicttype +} + +testcase TC_Sem_06020504_embedding_fields_001() runs on GeneralComp { + + var Anytype a := { boolean := false }; + + a.verdicttype := pass; // Equivalent to a.R.verdicttype := pass; + if (ischosen(a.R)) { + setverdict(pass) + } else { + setverdict(fail, "a.R is not chosen") + } + + a.integer := 1; // Not equivalent to a.R.integer := 1; + if (ischosen(a.integer)) { + setverdict(pass) + } else { + setverdict(fail, "a.integer is not chosen") + } +} + +control { + execute(TC_Sem_06020504_embedding_fields_001()); +} + +} -- GitLab From bddc406eacf3a14f24dcf4a8689f813d6e4045b1 Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Mon, 20 Feb 2023 16:22:47 +0100 Subject: [PATCH 05/14] Add tests for automatic type for literals and return values --- .../NegSem_0605_automatic_type_001.ttcn | 10 ++++++++ .../NegSem_0605_automatic_type_002.ttcn | 8 ++++++ .../NegSem_0605_automatic_type_003.ttcn | 8 ++++++ .../NegSem_0605_literals_001.ttcn | 8 ++++++ .../NegSem_0605_literals_002.ttcn | 8 ++++++ .../Sem_0605_automatic_type_001.ttcn | 10 ++++++++ .../Sem_0605_automatic_type_002.ttcn | 11 ++++++++ .../Sem_0605_automatic_type_003.ttcn | 8 ++++++ .../Sem_0605_automatic_type_004.ttcn | 11 ++++++++ .../Sem_0605_automatic_type_005.ttcn | 8 ++++++ .../Sem_0605_literals_001.ttcn | 23 +++++++++++++++++ .../Sem_0605_literals_002.ttcn | 25 +++++++++++++++++++ .../Sem_0605_literals_003.ttcn | 25 +++++++++++++++++++ .../Sem_0605_literals_004.ttcn | 21 ++++++++++++++++ .../Sem_0605_literals_005.ttcn | 21 ++++++++++++++++ .../Sem_0605_literals_006.ttcn | 21 ++++++++++++++++ .../Sem_0605_literals_007.ttcn | 23 +++++++++++++++++ .../Sem_0605_literals_008.ttcn | 21 ++++++++++++++++ .../Sem_0605_literals_009.ttcn | 22 ++++++++++++++++ .../Sem_0605_return_values_001.ttcn | 25 +++++++++++++++++++ .../Sem_0605_return_values_002.ttcn | 21 ++++++++++++++++ .../Sem_0605_return_values_003.ttcn | 24 ++++++++++++++++++ .../Sem_0605_return_values_004.ttcn | 20 +++++++++++++++ .../Sem_0605_return_values_005.ttcn | 19 ++++++++++++++ .../Sem_0605_return_values_006.ttcn | 21 ++++++++++++++++ .../Sem_0605_return_values_007.ttcn | 21 ++++++++++++++++ .../Sem_0605_return_values_008.ttcn | 21 ++++++++++++++++ .../Sem_0605_return_values_009.ttcn | 24 ++++++++++++++++++ .../Sem_0605_return_values_010.ttcn | 19 ++++++++++++++ 29 files changed, 507 insertions(+) create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_002.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_003.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_002.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_002.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_003.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_004.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_005.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_002.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_003.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_004.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_005.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_006.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_007.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_008.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_009.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_002.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_003.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_004.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_005.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_006.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_007.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_008.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_009.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_010.ttcn diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_001.ttcn new file mode 100644 index 0000000..842eaf6 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_001.ttcn @@ -0,0 +1,10 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure ArrayDef part is omitted for variables with automatic type inference. + // @verdict pass reject +module NegSem_0605_automatic_type_001 { + +function f() { + var x[2] := {1,2}; +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_002.ttcn new file mode 100644 index 0000000..1071a4e --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_002.ttcn @@ -0,0 +1,8 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure ArrayDef part is omitted for constants with automatic type inference. + // @verdict pass reject +module NegSem_0605_automatic_type_002 { + +const IP[4] := { 192, 168, 0, 1 }; + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_003.ttcn new file mode 100644 index 0000000..bb7c227 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_003.ttcn @@ -0,0 +1,8 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure ambiguous types are rejected. + // @verdict pass reject +module NegSem_0605_automatic_type_003 { + +const X := null; + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_001.ttcn new file mode 100644 index 0000000..7a75180 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_001.ttcn @@ -0,0 +1,8 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for *. + // @verdict pass reject +module NegSem_0605_literals_001 { + +modulepar template mpar := *; + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_002.ttcn new file mode 100644 index 0000000..d5e49f4 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_002.ttcn @@ -0,0 +1,8 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for ?. + // @verdict pass reject +module NegSem_0605_literals_002 { + +modulepar template mpar := ? + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_001.ttcn new file mode 100644 index 0000000..f31b8bb --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_001.ttcn @@ -0,0 +1,10 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure variables provide automatic type inference. + // @verdict pass accept +module Sem_0605_automatic_type_001 { + +function f() { + var x := 1; +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_002.ttcn new file mode 100644 index 0000000..6c269b4 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_002.ttcn @@ -0,0 +1,11 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure template variables provide automatic type inference. + // @verdict pass accept +module Sem_0605_automatic_type_002 { + +function f() { + var template t1 := 1; + var omit t2 := 2; +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_003.ttcn new file mode 100644 index 0000000..42f8f1b --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_003.ttcn @@ -0,0 +1,8 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure constants provide automatic type inference. + // @verdict pass accept +module Sem_0605_automatic_type_003 { + +const X := 23; + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_004.ttcn new file mode 100644 index 0000000..81fb798 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_004.ttcn @@ -0,0 +1,11 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure fuzzy variables provide automatic type inference. + // @verdict pass accept +module Sem_0605_automatic_type_004 { + +function f() { + var @fuzzy x := 1; +} + + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_005.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_005.ttcn new file mode 100644 index 0000000..07d73a9 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_005.ttcn @@ -0,0 +1,8 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure module parameter provide automatic type inference. + // @verdict pass accept +module Sem_0605_automatic_type_005 { + +modulepar mpar := 1; + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_001.ttcn new file mode 100644 index 0000000..17366cb --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_001.ttcn @@ -0,0 +1,23 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for integer literals. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_literals_001 { + +type component GeneralComp {} + +// inout parameters require strong typing and can be used to type verification. +function verifyType(inout integer i) { + setverdict(pass); +} + +testcase TC_Sem_0605_literals_001() runs on GeneralComp { + { var v := -1; verifyType(i) } + { var v := 0; verifyType(i) } + { var v := 2; verifyType(i) } +} + +control { + execute(TC_Sem_0605_literals_001()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_002.ttcn new file mode 100644 index 0000000..59c87a8 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_002.ttcn @@ -0,0 +1,25 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for verdicttype literals. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_literals_002 { + +type component GeneralComp {} + +// inout parameters require strong typing and can be used to type verification. +function verifyType(inout verdicttype v) { + setverdict(pass); +} + +testcase TC_Sem_0605_literals_002() runs on GeneralComp { + { var v := none; verifyType(v); } + { var v := pass; verifyType(v); } + { var v := inconc; verifyType(v); } + { var v := fail; verifyType(v); } + { var v := error; verifyType(v); } +} + +control { + execute(TC_Sem_0605_literals_002()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_003.ttcn new file mode 100644 index 0000000..1f87bf0 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_003.ttcn @@ -0,0 +1,25 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for float literals. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_literals_003 { + +type component GeneralComp {} + +// inout parameters require strong typing and can be used to type verification. +function verifyType(inout float f) { + setverdict(pass); +} + +testcase TC_Sem_0605_literals_003() runs on GeneralComp { + { var v := -1.0; verifyType(v) } + { var v := not_a_number; verifyType(v) } + { var v := -infinity; verifyType(v) } + { var v := infinity; verifyType(v) } + { var v := 0.3; verifyType(v) } +} + +control { + execute(TC_Sem_0605_literals_003()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_004.ttcn new file mode 100644 index 0000000..0e23db1 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_004.ttcn @@ -0,0 +1,21 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for bitstring literals. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_literals_004 { + +type component GeneralComp {} + +// inout parameters require strong typing and can be used to type verification. +function verifyType(inout bitstring bs) { + setverdict(pass); +} + +testcase TC_Sem_0605_literals_004() runs on GeneralComp { + { var v := '1'B; verifyType(v) } +} + +control { + execute(TC_Sem_0605_literals_004()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_005.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_005.ttcn new file mode 100644 index 0000000..44ac10b --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_005.ttcn @@ -0,0 +1,21 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for hexstring literals. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_literals_005 { + +type component GeneralComp {} + +// inout parameters require strong typing and can be used to type verification. +function verifyType(inout hexstring hs) { + setverdict(pass); +} + +testcase TC_Sem_0605_literals_005() runs on GeneralComp { + { var v := '5'H; verifyType(v) } +} + +control { + execute(TC_Sem_0605_literals_005()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_006.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_006.ttcn new file mode 100644 index 0000000..4b48839 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_006.ttcn @@ -0,0 +1,21 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for octetstring literals. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_literals_006 { + +type component GeneralComp {} + +// inout parameters require strong typing and can be used to type verification. +function verifyType(inout octetstring os) { + setverdict(pass); +} + +testcase TC_Sem_0605_literals_006() runs on GeneralComp { + { var v := '03'O; verifyType(v) } +} + +control { + execute(TC_Sem_0605_literals_006()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_007.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_007.ttcn new file mode 100644 index 0000000..c248959 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_007.ttcn @@ -0,0 +1,23 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for charstring literals. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_literals_007 { + +type component GeneralComp {} + +// inout parameters require strong typing and can be used to type verification. +function verifyType(inout charstring cs) { + setverdict(pass); +} + +testcase TC_Sem_0605_literals_007() runs on GeneralComp { + { var v := ""; verifyType(v) } + { var v := "abc"; verifyType(v) } + { var v := __MODULE__; verifyType(v) } +} + +control { + execute(TC_Sem_0605_literals_007()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_008.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_008.ttcn new file mode 100644 index 0000000..eece987 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_008.ttcn @@ -0,0 +1,21 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for universal charstring literals. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_literals_008 { + +type component GeneralComp {} + +// inout parameters require strong typing and can be used to type verification. +function verifyType(inout universal charstring us) { + setverdict(pass); +} + +testcase TC_Sem_0605_literals_008() runs on GeneralComp { + { var v := "Wörld"; verifyType(v); } +} + +control { + execute(TC_Sem_0605_literals_008()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_009.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_009.ttcn new file mode 100644 index 0000000..03cef66 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_009.ttcn @@ -0,0 +1,22 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for boolean literals. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_literals_009 { + +type component GeneralComp {} + +// inout parameters require strong typing and can be used to type verification. +function verifyType(inout boolean b) { + setverdict(pass); +} + +testcase TC_Sem_0605_literals_009() runs on GeneralComp { + { var v := true; verifyType(v) } + { var v := false; verifyType(v) } +} + +control { + execute(TC_Sem_0605_literals_009()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_001.ttcn new file mode 100644 index 0000000..d3acfa7 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_001.ttcn @@ -0,0 +1,25 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for user defined functions. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_return_values_001 { + +type component GeneralComp {} + +type integer Alias; + +function f() return Alias { return 1; } + +function verifyType(inout Alias a) { + setverdict(pass); +} + +testcase TC_Sem_0605_return_values_001() runs on GeneralComp { + var v := f(); + verifyType(v); +} + +control { + execute(TC_Sem_0605_return_values_001()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_002.ttcn new file mode 100644 index 0000000..6e089ab --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_002.ttcn @@ -0,0 +1,21 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for substr. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_return_values_002 { + +type component GeneralComp {} + +function verifyType(inout bitstring bs) { + setverdict(pass); +} + +testcase TC_Sem_0605_return_values_002() runs on GeneralComp { + var v := substr('00100110'B, 3, 4); + verifyType(v); +} + +control { + execute(TC_Sem_0605_return_values_002()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_003.ttcn new file mode 100644 index 0000000..71b9953 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_003.ttcn @@ -0,0 +1,24 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for valueof. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_return_values_003 { + +type component GeneralComp {} + +type integer Alias; +template Alias t := 1; + +function verifyType(inout Alias a) { + setverdict(pass); +} + +testcase TC_Sem_0605_return_values_003() runs on GeneralComp { + var v := valueof(t); + verifyType(v); +} + +control { + execute(TC_Sem_0605_return_values_003()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_004.ttcn new file mode 100644 index 0000000..d68afa2 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_004.ttcn @@ -0,0 +1,20 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for ischosen. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_return_values_004 { + +type component GeneralComp {} + +testcase TC_Sem_0605_return_values_004() runs on GeneralComp { + var anytype a := { integer := 23 }; + var v := ischosen(a.integer); + if (v) { + setverdict(pass); + } +} + +control { + execute(TC_Sem_0605_return_values_004()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_005.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_005.ttcn new file mode 100644 index 0000000..88e2b4e --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_005.ttcn @@ -0,0 +1,19 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for match. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_return_values_005 { + +type component GeneralComp {} + +testcase TC_Sem_0605_return_values_005() runs on GeneralComp { + var v := match(23, integer:(); + if (v) { + setverdict(pass); + } +} + +control { + execute(TC_Sem_0605_return_values_005()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_006.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_006.ttcn new file mode 100644 index 0000000..dd29057 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_006.ttcn @@ -0,0 +1,21 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for execute. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_return_values_006 { + +type component GeneralComp {} + +testcase TC_Sem_0605_return_values_006(inout verdicttype v) runs on GeneralComp { + setverdict(v); +} + +testcase TC_Sem_0605_return_values_006_dummy() runs on GeneralComp { + setverdict(pass); +} + +control { + var v := execute(TC_Sem_0605_return_values_006_dummy()); + execute(TC_Sem_0605_return_values_006(v)); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_007.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_007.ttcn new file mode 100644 index 0000000..9d3dc67 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_007.ttcn @@ -0,0 +1,21 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for create. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_return_values_007 { + +type component GeneralComp {} + +function f() runs on GeneralComp {} + +testcase TC_Sem_0605_return_values_007() runs on GeneralComp { + var c := GeneralComp.create; + c.start(f()); + c.done; + setverdict(pass); +} + +control { + execute(TC_Sem_0605_return_values_007()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_008.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_008.ttcn new file mode 100644 index 0000000..0dce6fc --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_008.ttcn @@ -0,0 +1,21 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for patterns. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_return_values_008 { + +type component GeneralComp {} + +function verifyType(inout template charstring cs) { + setpass(pass) +} + +testcase TC_Sem_0605_return_values_008() runs on GeneralComp { + var v := pattern "a*"; + verifyType(v) +} + +control { + execute(TC_Sem_0605_return_values_008()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_009.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_009.ttcn new file mode 100644 index 0000000..6da3d4b --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_009.ttcn @@ -0,0 +1,24 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for extension. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_return_values_009 { + +type component GeneralComp {} + +type integer int with { extension "ext" } +type record of universal charstring RoS; + + +testcase TC_Sem_0605_return_values_009() runs on GeneralComp { + var v := int.extension; + var Ros expected := { "ext" }; + if (v == expected) { + setverdict(pass); + } +} + +control { + execute(TC_Sem_0605_return_values_009()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_010.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_010.ttcn new file mode 100644 index 0000000..46c4fa0 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_010.ttcn @@ -0,0 +1,19 @@ + // @author TTF23 + // @purpose 1:6.5, Ensure automatic type for activate. + // @verdict pass accept, ttcn3verdict:pass +module Sem_0605_return_values_009 { + +type component GeneralComp {} + +altstep as() {} + +testcase TC_Sem_0605_return_values_009() runs on GeneralComp { + var v := activate(as()); + deactivate(v); +} + +control { + execute(TC_Sem_0605_return_values_009()); +} + +} -- GitLab From 029a4bd51c4e4c4e1e17acaa43e0997614eaf622 Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Wed, 15 Mar 2023 16:57:21 +0100 Subject: [PATCH 06/14] Add tests for automatic type for references --- .../NegSem_0605_references_001.ttcn | 18 +++++++++++++ .../Sem_0605_references_001.ttcn | 24 +++++++++++++++++ .../Sem_0605_references_002.ttcn | 22 +++++++++++++++ .../Sem_0605_references_003.ttcn | 26 ++++++++++++++++++ .../Sem_0605_references_004.ttcn | 24 +++++++++++++++++ .../Sem_0605_references_005.ttcn | 23 ++++++++++++++++ .../Sem_0605_references_006.ttcn | 22 +++++++++++++++ .../Sem_0605_references_007.ttcn | 21 +++++++++++++++ .../Sem_0605_references_008.ttcn | 25 +++++++++++++++++ .../Sem_0605_references_009.ttcn | 11 ++++++++ .../Sem_0605_references_010.ttcn | 24 +++++++++++++++++ .../Sem_0605_references_011.ttcn | 25 +++++++++++++++++ .../Sem_0605_references_012.ttcn | 26 ++++++++++++++++++ .../Sem_0605_references_013.ttcn | 27 +++++++++++++++++++ .../Sem_0605_references_014.ttcn | 27 +++++++++++++++++++ 15 files changed, 345 insertions(+) create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_references_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_002.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_003.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_004.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_005.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_006.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_007.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_008.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_009.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_010.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_011.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_012.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_013.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_014.ttcn diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_references_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_references_001.ttcn new file mode 100644 index 0000000..89a4403 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_references_001.ttcn @@ -0,0 +1,18 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for templates. +// @verdict pass reject +module NegSem_0605_references_001 { + +type component GeneralComp {} + +template integer t_int := ?; + +testcase TC_NegSem_0605_references_001() runs on GeneralComp { + var v := t_int; // error: v must be declared as template explicitly. +} + +control { + execute(TC_NegSem_0605_references_001()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_001.ttcn new file mode 100644 index 0000000..a64c057 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_001.ttcn @@ -0,0 +1,24 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for variables. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_references_001 { + +type component GeneralComp {} + +type integer int; + +function verifyType(inout int i) { + setverdict(pass); +} + +testcase TC_Sem_0605_references_001() runs on GeneralComp { + var int i := 1; + var v := i; + verifyType(v); +} + +control { + execute(TC_Sem_0605_references_001()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_002.ttcn new file mode 100644 index 0000000..bd54eeb --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_002.ttcn @@ -0,0 +1,22 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for arrays. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_references_002 { + +type component GeneralComp {} + +function verifyType(inout integer a[3]) { + setverdict(pass); +} + +testcase TC_Sem_0605_references_002() runs on GeneralComp { + var integer a[3]; + var v := a; + verifyType(v); +} + +control { + execute(TC_Sem_0605_references_002()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_003.ttcn new file mode 100644 index 0000000..627ef0a --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_003.ttcn @@ -0,0 +1,26 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for lazy variables. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_references_003 { + +type component GeneralComp {} + +function verifyType(inout universal charstring uc) { + setverdict(pass); +} + +testcase TC_Sem_0605_references_003() runs on GeneralComp { + var @lazy v1 := "üniversal charstrüng"; + { + var charstring v2 := "charstring"; + v1 := v2; + } + var v3 := v1; + verifyType(v3); +} + +control { + execute(TC_Sem_0605_references_003()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_004.ttcn new file mode 100644 index 0000000..79ced2b --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_004.ttcn @@ -0,0 +1,24 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for module parameter references. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_references_004 { + +type component GeneralComp {} + +modulepar integer mp := 2; + +testcase TC_Sem_0605_references_004() runs on GeneralComp { + var i := mp; + i := i + 1; + if (i == 3) { + setverdict(pass); + } else { + setverdict(fail); + } +} + +control { + execute(TC_Sem_0605_references_004()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_005.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_005.ttcn new file mode 100644 index 0000000..6d2234d --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_005.ttcn @@ -0,0 +1,23 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for templates. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_references_005 { + +type component GeneralComp {} + +template integer t_int := ? + +testcase TC_Sem_0605_references_005() runs on GeneralComp { + var template v := t_int; + if (match(1, v)) { + setverdict(pass); + } else { + setverdict(fail); + } +} + +control { + execute(TC_Sem_0605_references_005()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_006.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_006.ttcn new file mode 100644 index 0000000..c42328e --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_006.ttcn @@ -0,0 +1,22 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for modified templates. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_references_006 { + +type component GeneralComp {} + +function verifyType(inout template integer ti) { + setverdict(pass); +} + +testcase TC_Sem_0605_references_006() runs on GeneralComp { + var template integer t1 := ?; + var template v := modifies t1 := 2; + verifyType(v); +} + +control { + execute(TC_Sem_0605_references_006()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_007.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_007.ttcn new file mode 100644 index 0000000..31d8a41 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_007.ttcn @@ -0,0 +1,21 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for components. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_references_007 { + +type component GeneralComp {} + +verifyType(inout GeneralComp c) { + setverdict(pass); +} + +testcase TC_Sem_0605_references_007() runs on GeneralComp { + var c := mtc; + verifyType(c); +} + +control { + execute(TC_Sem_0605_references_007()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_008.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_008.ttcn new file mode 100644 index 0000000..949afee --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_008.ttcn @@ -0,0 +1,25 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for ports. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_references_008 { + +type component GeneralComp { + port Port p; +} + +type port Port message { inout integer } + +verifyType(inout Port p) { + setverdict(pass); +} + +testcase TC_Sem_0605_references_008() runs on GeneralComp { + var v := p; + verifyType(v); +} + +control { + execute(TC_Sem_0605_references_008()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_009.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_009.ttcn new file mode 100644 index 0000000..857ef53 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_009.ttcn @@ -0,0 +1,11 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for timer. +// @verdict pass accept +module Sem_0605_references_009 { + +type component GeneralComp { + timer t; + var v := t; +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_010.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_010.ttcn new file mode 100644 index 0000000..ff2d289 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_010.ttcn @@ -0,0 +1,24 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for constants. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_references_010 { + +const integer I := 1; + +type component GeneralComp {} + +testcase TC_Sem_0605_references_010() runs on GeneralComp { + var i := I; + i := i + 1; + if (i == 2) { + setverdict(pass); + } else { + setverdict(fail); + } +} + +control { + execute(TC_Sem_0605_references_010()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_011.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_011.ttcn new file mode 100644 index 0000000..813c876 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_011.ttcn @@ -0,0 +1,25 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for parameters. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_references_011 { + +type component GeneralComp {} + +function verifyType(inout integer i) { + setverdict(pass); +} + +function f(integer i) returns integer { + var j := i; + verifyType(j); +} + +testcase TC_Sem_0605_references_011() runs on GeneralComp { + f(1); +} + +control { + execute(TC_Sem_0605_references_011()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_012.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_012.ttcn new file mode 100644 index 0000000..d1fc6e5 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_012.ttcn @@ -0,0 +1,26 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for field references. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_references_012 { + +type component GeneralComp {} + +type record R { + record { integer i, float f, } nr; +} + +function verifyType(inout R.nr nr) { + setverdict(pass); +} + +testcase TC_Sem_0605_references_012() runs on GeneralComp { + var R r := { nr := { i := 1, f := 1.0 } }; + var v := r.nr; + verifyType(v); +} + +control { + execute(TC_Sem_0605_references_012()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_013.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_013.ttcn new file mode 100644 index 0000000..fddb2ca --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_013.ttcn @@ -0,0 +1,27 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for references to unions; +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_references_013 { + +type component GeneralComp {} + +type union U { + universal charstring ucs, + integer i, +} + +function verifyType(inout U u) { + setverdict(pass); +} + +testcase TC_Sem_0605_references_013() runs on GeneralComp { + var U u := { i := 1 }; + var v := u; + verifyType(v); +} + +control { + execute(TC_Sem_0605_references_013()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_014.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_014.ttcn new file mode 100644 index 0000000..18bc5a0 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_014.ttcn @@ -0,0 +1,27 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for references to union default variants. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_references_014 { + +type component GeneralComp {} + +type union U { + @default universal charstring ucs, + integer i +} + +function verifyType(inout U u) { + setverdict(pass); +} + +testcase TC_Sem_0605_references_014() runs on GeneralComp { + var U u := "hello"; + var v := u; + verifyType(v); +} + +control { + execute(TC_Sem_0605_references_014()); +} + +} -- GitLab From fdf5cae48c9b269f1a913bbd81135676d31e226c Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Wed, 5 Apr 2023 16:45:22 +0200 Subject: [PATCH 07/14] Add tests for expressions --- .../NegSem_0605_expressions_001.ttcn | 18 ++++++++++++++ .../Sem_0605_expressions_001.ttcn | 21 ++++++++++++++++ .../Sem_0605_expressions_002.ttcn | 24 +++++++++++++++++++ .../Sem_0605_expressions_003.ttcn | 21 ++++++++++++++++ .../Sem_0605_expressions_004.ttcn | 21 ++++++++++++++++ 5 files changed, 105 insertions(+) create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_expressions_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_002.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_003.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_004.ttcn diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_expressions_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_expressions_001.ttcn new file mode 100644 index 0000000..9bb1d9e --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_expressions_001.ttcn @@ -0,0 +1,18 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure qualified enumerated values. +// @verdict pass reject +module NegSem_0605_expressions_001 { + +type component GeneralComp {} + +type enumerated E { A(1), B(2) } + +testcase TC_NegSem_0605_expressions_001() runs on GeneralComp { + var e := A; +} + +control { + execute(TC_NegSem_0605_expressions_001()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_001.ttcn new file mode 100644 index 0000000..8e6dbd4 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_001.ttcn @@ -0,0 +1,21 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for expressions. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_expressions_001 { + +type component GeneralComp {} + +testcase TC_Sem_0605_expressions_001() runs on GeneralComp { + var cond := 1 + 2 <= 3; + if (cond == true) { + setverdict(pass); + } else { + setverdict(fail); + } +} + +control { + execute(TC_Sem_0605_expressions_001()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_002.ttcn new file mode 100644 index 0000000..7c6062b --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_002.ttcn @@ -0,0 +1,24 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure qualified enumerated values. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_expressions_002 { + +type component GeneralComp {} + +type enumerated E { A(1), B(2) } +type enumerated F { B(3), C(4) } + +testcase TC_Sem_0605_expressions_002() runs on GeneralComp { + var v := F.B; + if (enum2int(v) == 3) { + setverdict(pass); + } else { + setverdict(fail); + } +} + +control { + execute(TC_Sem_0605_expressions_002()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_003.ttcn new file mode 100644 index 0000000..4c9f177 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_003.ttcn @@ -0,0 +1,21 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for value ranges. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_expressions_003 { + +type component GeneralComp {} + +testcase TC_Sem_0605_expressions_003() runs on GeneralComp { + var v := (0.1..!0.2); + if (match(0.11, v)) { + setverdict(pass); + } else { + setverdict(fail); + } +} + +control { + execute(TC_Sem_0605_expressions_003()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_004.ttcn new file mode 100644 index 0000000..94c287a --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_004.ttcn @@ -0,0 +1,21 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure infinity bounds are inferred to integer. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_expressions_004 { + +type component GeneralComp {} + +testcase TC_Sem_0605_expressions_004() runs on GeneralComp { + var v := (-infinity..infinity); + if (match(7, v)) { + setverdict(pass); + } else { + setverdict(fail); + } +} + +control { + execute(TC_Sem_0605_expressions_004()); +} + +} -- GitLab From 6f7b16a0edfed2e17c614959f8fcb9ef5c7e61f2 Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Wed, 5 Apr 2023 17:03:19 +0200 Subject: [PATCH 08/14] Add tests for valuelists --- .../Sem_0605_value_lists_001.ttcn | 23 +++++++++++++++++++ .../Sem_0605_value_lists_002.ttcn | 21 +++++++++++++++++ 2 files changed, 44 insertions(+) create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_002.ttcn diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_001.ttcn new file mode 100644 index 0000000..47a516e --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_001.ttcn @@ -0,0 +1,23 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure common type of value lists is inferred. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_value_lists_001 { + +type component GeneralComp {} + +testcase TC_Sem_0605_value_lists_001() runs on GeneralComp { + var a := 1; + var b := {a, 2}; + var c := {{}, b, {3}}; + if (match(c, {{}, {1,2}, {3}})) { + setverdict(pass); + } else { + setverdict(fail); + } +} + +control { + execute(TC_Sem_0605_value_lists_001()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_002.ttcn new file mode 100644 index 0000000..ee8aaf2 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_002.ttcn @@ -0,0 +1,21 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure common type of value lists is inferred. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_value_lists_002 { + +type component GeneralComp {} + +function verifyType(inout universal charstring v) { + setverdict(pass); +} + +testcase TC_Sem_0605_value_lists_002() runs on GeneralComp { + var v := { "Hello", "Wörld" }; + verifyType(v); +} + +control { + execute(TC_Sem_0605_value_lists_002()); +} + +} -- GitLab From 59aef316102a5797fa305e7115fbb65b1a6e2256 Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Thu, 6 Apr 2023 07:47:11 +0200 Subject: [PATCH 09/14] Add tests for field assignment lists --- ...egSem_0605_field_assignment_lists_001.ttcn | 21 +++++++++++++++ .../Sem_0605_field_assignment_lists_001.ttcn | 26 +++++++++++++++++++ .../Sem_0605_field_assignment_lists_002.ttcn | 26 +++++++++++++++++++ 3 files changed, 73 insertions(+) create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_field_assignment_lists_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_002.ttcn diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_field_assignment_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_field_assignment_lists_001.ttcn new file mode 100644 index 0000000..05a8bac --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_field_assignment_lists_001.ttcn @@ -0,0 +1,21 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure field assignment lists are anonymous records. +// @verdict pass reject +module NegSem_0605_field_assignment_lists_001 { + +type component GeneralComp {} + +function verifyType(inout record { integer x, integer y } r) { + setverdict(pass); +} + +testcase TC_NegSem_0605_field_assignment_lists_001() runs on GeneralComp { + var v := { x := 1, y := 2 }; + verifyType(v); +} + +control { + execute(TC_NegSem_0605_field_assignment_lists_001()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_001.ttcn new file mode 100644 index 0000000..945ef92 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_001.ttcn @@ -0,0 +1,26 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure record fields have the same order as specified. +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_field_assignment_lists_001 { + +type component GeneralComp {} + +type record Point { + integer x, + integer y +} + +testcase TC_Sem_0605_field_assignment_lists_001() runs on GeneralComp { + var v := { x := 1, y := 2 } + if (match(v, Point:{x := 1, y := 2})) { + setverdict(pass); + } else { + setverdict(fail); + } +} + +control { + execute(TC_Sem_0605_field_assignment_lists_001()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_002.ttcn new file mode 100644 index 0000000..0e5c259 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_002.ttcn @@ -0,0 +1,26 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure record fields become optional as specified (15.8). +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_field_assignment_lists_002 { + +type component GeneralComp {} + +type record Point { + integer x, + integer y optional +} + +testcase TC_Sem_0605_field_assignment_lists_002() runs on GeneralComp { + var v := { x := 1, y := omit } + if (match(v, { x := 1, y := omit })) { + setverdict(pass); + } else { + setverdict(fail); + } +} + +control { + execute(TC_Sem_0605_field_assignment_lists_002()); +} + +} -- GitLab From 30154873490cd85f2f4a82694c70f44652bdd649 Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Thu, 6 Apr 2023 08:13:03 +0200 Subject: [PATCH 10/14] Add tests for index assignment lists --- .../NegSem_0605_index_lists_001.ttcn | 16 ++++++++++++++++ .../Sem_0605_index_lists_001.ttcn | 19 +++++++++++++++++++ .../Sem_0605_index_lists_002.ttcn | 19 +++++++++++++++++++ .../Sem_0605_index_lists_003.ttcn | 19 +++++++++++++++++++ 4 files changed, 73 insertions(+) create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_index_lists_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_001.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_002.ttcn create mode 100644 ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_003.ttcn diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_index_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_index_lists_001.ttcn new file mode 100644 index 0000000..f56c06f --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_index_lists_001.ttcn @@ -0,0 +1,16 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure index list with common key type keys is a map. +// @verdict pass reject +module NegSem_0605_index_lists_001 { + +type component GeneralComp {} + +testcase TC_NegSem_0605_index_lists_001() runs on GeneralComp { + var v := { ["Hello"] := 1, [1] := 2 }; +} + +control { + execute(TC_NegSem_0605_index_lists_001()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_001.ttcn new file mode 100644 index 0000000..1b901ee --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_001.ttcn @@ -0,0 +1,19 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure index list with integer key type is a record of. +// @verdict pass accept +module Sem_0605_index_lists_001 { + +type component GeneralComp {} + +type record of universal charstring RoUC; + +testcase TC_Sem_0605_index_lists_001() runs on GeneralComp { + var v := { [1] := "Hello", [3] := -, [5] := "Wörld" }; + var RoUC r := v; +} + +control { + execute(TC_Sem_0605_index_lists_001()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_002.ttcn new file mode 100644 index 0000000..034166a --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_002.ttcn @@ -0,0 +1,19 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure index list with common key type keys is a map. +// @verdict pass accept +module Sem_0605_index_lists_002 { + +type component GeneralComp {} + +type map from float to charstring M; + +testcase TC_Sem_0605_index_lists_002() runs on GeneralComp { + var v := { [1.0] := "a", [2.1] := "b" }; + var M m := v; +} + +control { + execute(TC_Sem_0605_index_lists_002()); +} + +} diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_003.ttcn new file mode 100644 index 0000000..2894051 --- /dev/null +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_003.ttcn @@ -0,0 +1,19 @@ +// @author TTF23 +// @purpose 1:6.5, Ensure index list with common key type keys is a map. +// @verdict pass accept +module Sem_0605_index_lists_003 { + +type component GeneralComp {} + +type map from universal charstring to integer M; + +testcase TC_Sem_0605_index_lists_003() runs on GeneralComp { + var v := { ["Hello"] := 5, ["Wörld"] := 23 }; + var M m := v; +} + +control { + execute(TC_Sem_0605_index_lists_003()); +} + +} -- GitLab From 1f9c7b08e0b1444b323bcd8700402184811483ca Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Thu, 6 Apr 2023 09:34:32 +0200 Subject: [PATCH 11/14] Add tests for nested types --- .../Sem_05040101_nested_types_001.ttcn | 20 +++++++++++++++++++ .../Sem_05040102_nested_types_001.ttcn | 20 +++++++++++++++++++ .../Sem_080201_nested_types_001.ttcn | 18 +++++++++++++++++ .../10_constants/Sem_10_nested_types_001.ttcn | 18 +++++++++++++++++ .../11_variables/Sem_11_nested_types_001.ttcn | 17 ++++++++++++++++ .../Sem_14_nested_types_001.ttcn | 20 +++++++++++++++++++ .../Sem_1601_nested_types_001.ttcn | 20 +++++++++++++++++++ 7 files changed, 133 insertions(+) create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040101_parameters_of_kind_value/Sem_05040101_nested_types_001.ttcn create mode 100644 ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040102_parameters_of_kind_template/Sem_05040102_nested_types_001.ttcn create mode 100644 ATS/core_language/08_modules/0802_module_definitions_part/080201_module_parameters/Sem_080201_nested_types_001.ttcn create mode 100644 ATS/core_language/10_constants/Sem_10_nested_types_001.ttcn create mode 100644 ATS/core_language/11_variables/Sem_11_nested_types_001.ttcn create mode 100644 ATS/core_language/14_procedure_signatures/Sem_14_nested_types_001.ttcn create mode 100644 ATS/core_language/16_functions_altsteps_testcases/1601_functions/1601_toplevel/Sem_1601_nested_types_001.ttcn diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040101_parameters_of_kind_value/Sem_05040101_nested_types_001.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040101_parameters_of_kind_value/Sem_05040101_nested_types_001.ttcn new file mode 100644 index 0000000..cc28d85 --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040101_parameters_of_kind_value/Sem_05040101_nested_types_001.ttcn @@ -0,0 +1,20 @@ +// @author TTF23 +// @purpose 1:5.4.1.1, Ensure formal parameters accept nested types. +// @verdict pass accept +module Sem_05040101_nested_types_001 { + +type component GeneralComp {} + +function f(in record of integer n) { + setverdict(pass); +} + +testcase TC_Sem_05040101_nested_types_001() runs on GeneralComp { + f({1,2,3,4}); +} + +control { + execute(TC_Sem_05040101_nested_types_001()); +} + +} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040102_parameters_of_kind_template/Sem_05040102_nested_types_001.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040102_parameters_of_kind_template/Sem_05040102_nested_types_001.ttcn new file mode 100644 index 0000000..bd520dd --- /dev/null +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040102_parameters_of_kind_template/Sem_05040102_nested_types_001.ttcn @@ -0,0 +1,20 @@ +// @author TTF23 +// @purpose 1:5.4.1.2, Ensure formal parameters accept nested types. +// @verdict pass accept +module Sem_05040102_nested_types_001 { + +type component GeneralComp {} + +function f(template record of integer n) { + setverdict(pass); +} + +testcase TC_Sem_05040102_nested_types_001() runs on GeneralComp { + f({1,?,3}); +} + +control { + execute(TC_Sem_05040102_nested_types_001()); +} + +} diff --git a/ATS/core_language/08_modules/0802_module_definitions_part/080201_module_parameters/Sem_080201_nested_types_001.ttcn b/ATS/core_language/08_modules/0802_module_definitions_part/080201_module_parameters/Sem_080201_nested_types_001.ttcn new file mode 100644 index 0000000..aeaf8a2 --- /dev/null +++ b/ATS/core_language/08_modules/0802_module_definitions_part/080201_module_parameters/Sem_080201_nested_types_001.ttcn @@ -0,0 +1,18 @@ +// @author TTF23 +// @purpose 1:8.2.1, Ensure module parameters accept nested types. +// @verdict pass accept +module Sem_080201_nested_types_001 { + +modulepar record of charstring IDs := {1,2,3}; + +type component GeneralComp {} + +testcase TC_Sem_080201_nested_types_001() runs on GeneralComp { + setverdict(pass); +} + +control { + execute(TC_Sem_080201_nested_types_001()); +} + +} diff --git a/ATS/core_language/10_constants/Sem_10_nested_types_001.ttcn b/ATS/core_language/10_constants/Sem_10_nested_types_001.ttcn new file mode 100644 index 0000000..2526848 --- /dev/null +++ b/ATS/core_language/10_constants/Sem_10_nested_types_001.ttcn @@ -0,0 +1,18 @@ +// @author TTF23 +// @purpose 1:10, Ensure constants accept nested types. +// @verdict pass accept +module Sem_10_nested_types_001 { + +const record of integer := { 1,2,3 }; + +type component GeneralComp {} + +testcase TC_Sem_10_nested_types_001() runs on GeneralComp { + setverdict(pass); +} + +control { + execute(TC_Sem_10_nested_types_001()); +} + +} diff --git a/ATS/core_language/11_variables/Sem_11_nested_types_001.ttcn b/ATS/core_language/11_variables/Sem_11_nested_types_001.ttcn new file mode 100644 index 0000000..6035f2d --- /dev/null +++ b/ATS/core_language/11_variables/Sem_11_nested_types_001.ttcn @@ -0,0 +1,17 @@ +// @author TTF23 +// @purpose 1:11, Ensure variables accept nested types. +// @verdict pass accept +module Sem_11_nested_types_001 { + +type component GeneralComp {} + +testcase TC_Sem_11_nested_types_001() runs on GeneralComp { + var template record of integer t := {1, *, 3}; + var record {} v[3]; +} + +control { + execute(TC_Sem_11_nested_types_001()); +} + +} diff --git a/ATS/core_language/14_procedure_signatures/Sem_14_nested_types_001.ttcn b/ATS/core_language/14_procedure_signatures/Sem_14_nested_types_001.ttcn new file mode 100644 index 0000000..b21a6fe --- /dev/null +++ b/ATS/core_language/14_procedure_signatures/Sem_14_nested_types_001.ttcn @@ -0,0 +1,20 @@ +// @author TTF23 +// @purpose 1:14, Ensure signatures accept nested types. +// @verdict pass accept +module Sem_14_nested_types_001 { + +type component GeneralComp {} + +signature A() return record of integer; +signature B(record of integer p); +signature C() exception (record {}); + +testcase TC_Sem_14_nested_types_001() runs on GeneralComp { + setverdict(pass); +} + +control { + execute(TC_Sem_14_nested_types_001()); +} + +} diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/1601_toplevel/Sem_1601_nested_types_001.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/1601_toplevel/Sem_1601_nested_types_001.ttcn new file mode 100644 index 0000000..d2b835a --- /dev/null +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/1601_toplevel/Sem_1601_nested_types_001.ttcn @@ -0,0 +1,20 @@ +// @author TTF23 +// @purpose 1:16.1.0, Ensure functions accept nested return types. +// @verdict pass accept +module Sem_1601_nested_types_001 { + +type component GeneralComp {} + +function f() returns record of record {}[3] { + setverdict(pass); +} + +testcase TC_Sem_1601_nested_types_001() runs on GeneralComp { + f(); +} + +control { + execute(TC_Sem_1601_nested_types_001()); +} + +} -- GitLab From c2cd3271895e4881382ce19312f2ba678ca823e1 Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Thu, 6 Apr 2023 10:55:42 +0200 Subject: [PATCH 12/14] Fix expected verdict --- ..._001.ttcn => Sem_0605_field_assignment_lists_003.ttcn} | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) rename ATS/core_language/06_types_and_values/0605_automatic_type/{NegSem_0605_field_assignment_lists_001.ttcn => Sem_0605_field_assignment_lists_003.ttcn} (55%) diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_field_assignment_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_003.ttcn similarity index 55% rename from ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_field_assignment_lists_001.ttcn rename to ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_003.ttcn index 05a8bac..638321d 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_field_assignment_lists_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_003.ttcn @@ -1,7 +1,7 @@ // @author TTF23 // @purpose 1:6.5, Ensure field assignment lists are anonymous records. -// @verdict pass reject -module NegSem_0605_field_assignment_lists_001 { +// @verdict pass accept, ttcn3verdict:pass +module Sem_0605_field_assignment_lists_003 { type component GeneralComp {} @@ -9,13 +9,13 @@ function verifyType(inout record { integer x, integer y } r) { setverdict(pass); } -testcase TC_NegSem_0605_field_assignment_lists_001() runs on GeneralComp { +testcase TC_Sem_0605_field_assignment_lists_003() runs on GeneralComp { var v := { x := 1, y := 2 }; verifyType(v); } control { - execute(TC_NegSem_0605_field_assignment_lists_001()); + execute(TC_Sem_0605_field_assignment_lists_003()); } } -- GitLab From 388e71d10d17be8c54a33ebd3c6825ee3294da04 Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Thu, 6 Apr 2023 10:55:49 +0200 Subject: [PATCH 13/14] Fix formatting --- .../Sem_05040101_nested_types_001.ttcn | 6 +++--- .../Sem_05040102_nested_types_001.ttcn | 4 ++-- .../NegSem_050403_variadic_parameters_001.ttcn | 8 ++++---- .../NegSem_050403_variadic_parameters_002.ttcn | 6 +++--- .../NegSem_050403_variadic_parameters_003.ttcn | 6 +++--- .../NegSem_050403_variadic_parameters_004.ttcn | 10 +++++----- .../NegSem_050403_variadic_parameters_005.ttcn | 10 +++++----- .../Sem_050403_variadic_parameters_001.ttcn | 6 +++--- .../Sem_050403_variadic_parameters_002.ttcn | 6 +++--- .../Sem_050403_variadic_parameters_003.ttcn | 6 +++--- .../Sem_050403_variadic_parameters_004.ttcn | 8 ++++---- .../Sem_050403_variadic_parameters_005.ttcn | 8 ++++---- .../Sem_050403_variadic_parameters_006.ttcn | 7 +++---- .../Sem_050403_variadic_parameters_007.ttcn | 8 ++++---- .../Sem_050403_variadic_parameters_008.ttcn | 8 ++++---- .../Sem_050403_variadic_parameters_009.ttcn | 11 +++++------ .../Sem_050403_variadic_parameters_010.ttcn | 14 +++++++------- .../Sem_050403_variadic_parameters_011.ttcn | 18 +++++++++--------- .../NegSem_06020104_embedding_fields_001.ttcn | 6 +++--- .../NegSem_06020104_embedding_fields_002.ttcn | 8 ++++---- .../Sem_06020104_embedding_fields_001.ttcn | 13 ++++++------- .../Sem_06020104_embedding_fields_002.ttcn | 8 ++++---- .../Sem_06020104_embedding_fields_003.ttcn | 8 ++++---- .../Sem_06020104_embedding_fields_004.ttcn | 9 ++++----- .../Sem_06020204_embedding_fields_001.ttcn | 6 +++--- .../Sem_06020504_embedding_fields_001.ttcn | 8 ++++---- .../NegSem_0605_automatic_type_001.ttcn | 8 ++++---- .../NegSem_0605_automatic_type_002.ttcn | 6 +++--- .../NegSem_0605_automatic_type_003.ttcn | 6 +++--- .../NegSem_0605_expressions_001.ttcn | 2 +- .../NegSem_0605_index_lists_001.ttcn | 2 +- .../NegSem_0605_literals_001.ttcn | 6 +++--- .../NegSem_0605_literals_002.ttcn | 6 +++--- .../NegSem_0605_references_001.ttcn | 2 +- .../Sem_0605_automatic_type_001.ttcn | 6 +++--- .../Sem_0605_automatic_type_002.ttcn | 6 +++--- .../Sem_0605_automatic_type_003.ttcn | 6 +++--- .../Sem_0605_automatic_type_004.ttcn | 7 +++---- .../Sem_0605_automatic_type_005.ttcn | 6 +++--- .../Sem_0605_expressions_001.ttcn | 2 +- .../Sem_0605_expressions_002.ttcn | 2 +- .../Sem_0605_expressions_003.ttcn | 2 +- .../Sem_0605_expressions_004.ttcn | 2 +- .../Sem_0605_field_assignment_lists_001.ttcn | 2 +- .../Sem_0605_field_assignment_lists_002.ttcn | 2 +- .../Sem_0605_field_assignment_lists_003.ttcn | 2 +- .../Sem_0605_index_lists_001.ttcn | 2 +- .../Sem_0605_index_lists_002.ttcn | 2 +- .../Sem_0605_index_lists_003.ttcn | 2 +- .../Sem_0605_literals_001.ttcn | 12 ++++++------ .../Sem_0605_literals_002.ttcn | 16 ++++++++-------- .../Sem_0605_literals_003.ttcn | 16 ++++++++-------- .../Sem_0605_literals_004.ttcn | 8 ++++---- .../Sem_0605_literals_005.ttcn | 8 ++++---- .../Sem_0605_literals_006.ttcn | 8 ++++---- .../Sem_0605_literals_007.ttcn | 12 ++++++------ .../Sem_0605_literals_008.ttcn | 8 ++++---- .../Sem_0605_literals_009.ttcn | 10 +++++----- .../Sem_0605_references_001.ttcn | 2 +- .../Sem_0605_references_002.ttcn | 2 +- .../Sem_0605_references_003.ttcn | 2 +- .../Sem_0605_references_004.ttcn | 2 +- .../Sem_0605_references_005.ttcn | 2 +- .../Sem_0605_references_006.ttcn | 2 +- .../Sem_0605_references_007.ttcn | 2 +- .../Sem_0605_references_008.ttcn | 2 +- .../Sem_0605_references_010.ttcn | 2 +- .../Sem_0605_references_011.ttcn | 2 +- .../Sem_0605_references_012.ttcn | 2 +- .../Sem_0605_references_013.ttcn | 2 +- .../Sem_0605_references_014.ttcn | 2 +- .../Sem_0605_return_values_001.ttcn | 8 ++++---- .../Sem_0605_return_values_002.ttcn | 8 ++++---- .../Sem_0605_return_values_003.ttcn | 8 ++++---- .../Sem_0605_return_values_004.ttcn | 8 ++++---- .../Sem_0605_return_values_005.ttcn | 18 +++++++++--------- .../Sem_0605_return_values_006.ttcn | 10 +++++----- .../Sem_0605_return_values_007.ttcn | 8 ++++---- .../Sem_0605_return_values_008.ttcn | 8 ++++---- .../Sem_0605_return_values_009.ttcn | 9 ++++----- .../Sem_0605_return_values_010.ttcn | 8 ++++---- .../Sem_0605_value_lists_001.ttcn | 4 ++-- .../Sem_0605_value_lists_002.ttcn | 2 +- .../Sem_080201_nested_types_001.ttcn | 4 ++-- .../10_constants/Sem_10_nested_types_001.ttcn | 4 ++-- .../11_variables/Sem_11_nested_types_001.ttcn | 2 +- .../Sem_14_nested_types_001.ttcn | 2 +- ...60106_the_not_implemented_function_000.ttcn | 8 ++++---- ...60106_the_not_implemented_function_001.ttcn | 8 ++++---- ...60106_the_not_implemented_function_002.ttcn | 8 ++++---- ...60106_the_not_implemented_function_003.ttcn | 8 ++++---- ...60106_the_not_implemented_function_004.ttcn | 8 ++++---- ...60106_the_not_implemented_function_005.ttcn | 8 ++++---- ...60106_the_not_implemented_function_006.ttcn | 8 ++++---- ...60106_the_not_implemented_function_007.ttcn | 8 ++++---- ...60106_the_not_implemented_function_008.ttcn | 8 ++++---- ...60106_the_not_implemented_function_001.ttcn | 8 ++++---- ...60106_the_not_implemented_function_002.ttcn | 8 ++++---- ...60106_the_not_implemented_function_003.ttcn | 8 ++++---- ...60106_the_not_implemented_function_004.ttcn | 8 ++++---- ...60106_the_not_implemented_function_005.ttcn | 8 ++++---- .../Sem_1601_nested_types_001.ttcn | 2 +- 102 files changed, 324 insertions(+), 330 deletions(-) diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040101_parameters_of_kind_value/Sem_05040101_nested_types_001.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040101_parameters_of_kind_value/Sem_05040101_nested_types_001.ttcn index cc28d85..d58609f 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040101_parameters_of_kind_value/Sem_05040101_nested_types_001.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040101_parameters_of_kind_value/Sem_05040101_nested_types_001.ttcn @@ -6,15 +6,15 @@ module Sem_05040101_nested_types_001 { type component GeneralComp {} function f(in record of integer n) { - setverdict(pass); + setverdict(pass); } testcase TC_Sem_05040101_nested_types_001() runs on GeneralComp { - f({1,2,3,4}); + f({1, 2, 3, 4}); } control { - execute(TC_Sem_05040101_nested_types_001()); + execute(TC_Sem_05040101_nested_types_001()); } } diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040102_parameters_of_kind_template/Sem_05040102_nested_types_001.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040102_parameters_of_kind_template/Sem_05040102_nested_types_001.ttcn index bd520dd..35823ff 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040102_parameters_of_kind_template/Sem_05040102_nested_types_001.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040102_parameters_of_kind_template/Sem_05040102_nested_types_001.ttcn @@ -10,11 +10,11 @@ function f(template record of integer n) { } testcase TC_Sem_05040102_nested_types_001() runs on GeneralComp { - f({1,?,3}); + f({1, ?, 3}); } control { - execute(TC_Sem_05040102_nested_types_001()); + execute(TC_Sem_05040102_nested_types_001()); } } diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_001.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_001.ttcn index 52ec0f9..e0dffe8 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_001.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_001.ttcn @@ -1,8 +1,8 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure variadic formal parameters are at the end of the formal parameter list. - // @verdict pass reject +// @author TTF23 +// @purpose 1:5.4.3, Ensure variadic formal parameters are at the end of the formal parameter list. +// @verdict pass reject module NegSem_050403_variadic_parameters_001 { - function f(in integer i..., in integer max) {} +function f(in integer i..., in integer max) {} } diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_002.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_002.ttcn index 269bc28..c1ce1c2 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_002.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_002.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure only one variadic formal parameter per formal parameter list is allowed. - // @verdict pass reject +// @author TTF23 +// @purpose 1:5.4.3, Ensure only one variadic formal parameter per formal parameter list is allowed. +// @verdict pass reject module NegSem_050403_variadic_parameters_002 { function f(in integer a..., in integer b...) {} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_003.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_003.ttcn index 469d32d..663e67e 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_003.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_003.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure variadic parameters are in parameters. - // @verdict pass reject +// @author TTF23 +// @purpose 1:5.4.3, Ensure variadic parameters are in parameters. +// @verdict pass reject module NegSem_050403_variadic_parameters_003 { function f1(inout integer x...) {} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_004.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_004.ttcn index 2868e67..6a9ed74 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_004.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_004.ttcn @@ -1,13 +1,13 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure actual variadic parameter results in an equivalent record of in their declaration order. - // @verdict pass reject +// @author TTF23 +// @purpose 1:5.4.3, Ensure actual variadic parameter results in an equivalent record of in their declaration order. +// @verdict pass reject module NegSem_050403_variadic_parameters_004 { type record of integer RoI; type component GeneralComp {} function f(in integers... args) return RoI { - return args + return args } testcase TC_NegSem_050403_variadic_parameters_004() runs on GeneralComp { @@ -15,7 +15,7 @@ testcase TC_NegSem_050403_variadic_parameters_004() runs on GeneralComp { } control { - execute(TC_NegSem_050403_variadic_parameters_004()); + execute(TC_NegSem_050403_variadic_parameters_004()); } } diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_005.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_005.ttcn index 13d8d9c..85b43c8 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_005.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_005.ttcn @@ -1,18 +1,18 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure an actual record of parameter in assignment notation has no additional ellipsis. - // @verdict pass reject +// @author TTF23 +// @purpose 1:5.4.3, Ensure an actual record of parameter in assignment notation has no additional ellipsis. +// @verdict pass reject module NegSem_050403_variadic_parameters_005 { type component GeneralComp {} testcase TC_NegSem_050403_variadic_parameters_005() runs on GeneralComp { - f(args := {1,2,3}...); + f(args := {1, 2, 3}...); } function f(in integer args...) {} control { - execute(TC_NegSem_050403_variadic_parameters_005()); + execute(TC_NegSem_050403_variadic_parameters_005()); } } diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_001.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_001.ttcn index 4792ed5..8af5c63 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_001.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_001.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure template definitions support variadic formal parameters. - // @verdict pass accept +// @author TTF23 +// @purpose 1:5.4.3, Ensure template definitions support variadic formal parameters. +// @verdict pass accept module Sem_050403_variadic_parameters_001 { type record of integer RoI; diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_002.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_002.ttcn index f139507..0c6131a 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_002.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_002.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure function definitions support variadic formal parameters. - // @verdict pass accept +// @author TTF23 +// @purpose 1:5.4.3, Ensure function definitions support variadic formal parameters. +// @verdict pass accept module Sem_050403_variadic_parameters_002 { function f(in integer i...) {} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_003.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_003.ttcn index bc196fb..b13dd0a 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_003.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_003.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure altstep definitions support variadic formal parameters. - // @verdict pass accept +// @author TTF23 +// @purpose 1:5.4.3, Ensure altstep definitions support variadic formal parameters. +// @verdict pass accept module Sem_050403_variadic_parameters_003 { altstep as1(in integer items...) {} diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_004.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_004.ttcn index 87a9914..4bfea63 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_004.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_004.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure testcase definitions support variadic formal parameters. - // @verdict pass accept, testverdict:pass +// @author TTF23 +// @purpose 1:5.4.3, Ensure testcase definitions support variadic formal parameters. +// @verdict pass accept, testverdict:pass module Sem_050403_variadic_parameters_004 { type component GeneralComp {} @@ -10,7 +10,7 @@ testcase TC_Sem_050403_variadic_parameters_004(in verdicttype verdicts...) runs } control { - execute(TC_Sem_050403_variadic_parameters_004()); + execute(TC_Sem_050403_variadic_parameters_004()); } } diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_005.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_005.ttcn index 15383cc..a7b2d2d 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_005.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_005.ttcn @@ -1,8 +1,8 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure variadic formal parameters may have default values. - // @verdict pass accept +// @author TTF23 +// @purpose 1:5.4.3, Ensure variadic formal parameters may have default values. +// @verdict pass accept module Sem_050403_variadic_parameters_005 { -function f(in integer i... := {1,2,3}) {} +function f(in integer i... := {1, 2, 3}) {} } diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_006.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_006.ttcn index 7582304..69ed97d 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_006.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_006.ttcn @@ -1,9 +1,8 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure variadic parameters are visible as record of types inside the defintion. - // @verdict pass accept +// @author TTF23 +// @purpose 1:5.4.3, Ensure variadic parameters are visible as record of types inside the defintion. +// @verdict pass accept module Sem_050403_variadic_parameters_006 { - type record of integer RoI; type record of integer RoA[3]; type record of C RoC; diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_007.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_007.ttcn index 02abcc5..5196976 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_007.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_007.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure omitted variadic parameter results in an empty record of. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:5.4.3, Ensure omitted variadic parameter results in an empty record of. +// @verdict pass accept, ttcn3verdict:pass module Sem_050403_variadic_parameters_007 { type component GeneralComp {} @@ -17,7 +17,7 @@ testcase TC_Sem_050403_variadic_parameters_007() runs on GeneralComp { function len(in integer args...) return integer { return lengthof(args) } control { - execute(TC_Sem_050403_variadic_parameters_007()); + execute(TC_Sem_050403_variadic_parameters_007()); } } diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_008.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_008.ttcn index 1d851fb..a3d0c7c 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_008.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_008.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure unused variadic parameter results in an empty record of. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:5.4.3, Ensure unused variadic parameter results in an empty record of. +// @verdict pass accept, ttcn3verdict:pass module Sem_050403_variadic_parameters_008 { type component GeneralComp {} @@ -18,7 +18,7 @@ testcase TC_Sem_050403_variadic_parameters_008() runs on GeneralComp { function len(in integer args...) return integer { return lengthof(args) } control { - execute(TC_Sem_050403_variadic_parameters_008()); + execute(TC_Sem_050403_variadic_parameters_008()); } } diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_009.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_009.ttcn index 070f6d2..ec902ca 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_009.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_009.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure actual variadic parameter results in an equivalent record of in their declaration order. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:5.4.3, Ensure actual variadic parameter results in an equivalent record of in their declaration order. +// @verdict pass accept, ttcn3verdict:pass module Sem_050403_variadic_parameters_009 { type record of integer Roi; @@ -23,16 +23,15 @@ testcase TC_Sem_050403_variadic_parameters_009() runs on GeneralComp { setverdict(fail, "f(1) != {1}"); } - if (f(1,2,3) == {1,2,3}) { + if (f(1, 2, 3) == {1, 2, 3}) { setverdict(pass); } else { setverdict(fail, "f(1,2,3) != {1,2,3}"); } } - control { - execute(TC_Sem_050403_variadic_parameters_009()); + execute(TC_Sem_050403_variadic_parameters_009()); } } diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_010.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_010.ttcn index 008e8fa..a65e3be 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_010.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_010.ttcn @@ -1,13 +1,13 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure an actual record of parameter with ... is passed directly to the formal variadic parameter. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:5.4.3, Ensure an actual record of parameter with ... is passed directly to the formal variadic parameter. +// @verdict pass accept, ttcn3verdict:pass module Sem_050403_variadic_parameters_010 { type record of integer RoI; type component GeneralComp {} function len(in integer args...) return integer { - return lengthof(args); + return lengthof(args); } testcase TC_Sem_050403_variadic_parameters_010() runs on GeneralComp { @@ -17,13 +17,13 @@ testcase TC_Sem_050403_variadic_parameters_010() runs on GeneralComp { setverdict(fail, "len({}...) != 0"); } - if (len({1,2,3}...) == 3) { + if (len({1, 2, 3}...) == 3) { setverdict(pass); } else { setverdict(fail, "len({1,2,3}...) != 3"); } - var RoI r := {1,2,3}; + var RoI r := {1, 2, 3}; if (len(r...) == 3) { setverdict(pass); } else { @@ -32,7 +32,7 @@ testcase TC_Sem_050403_variadic_parameters_010() runs on GeneralComp { } control { - execute(TC_Sem_050403_variadic_parameters_010()); + execute(TC_Sem_050403_variadic_parameters_010()); } } diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_011.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_011.ttcn index ae16c38..00b5554 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_011.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_011.ttcn @@ -1,24 +1,24 @@ - // @author TTF23 - // @purpose 1:5.4.3, Ensure an actual record of parameter in assignment notation is passed directly to the formal variadic parameter. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:5.4.3, Ensure an actual record of parameter in assignment notation is passed directly to the formal variadic parameter. +// @verdict pass accept, ttcn3verdict:pass module Sem_050403_variadic_parameters_011 { type component GeneralComp {} testcase TC_Sem_050403_variadic_parameters_011() runs on GeneralComp { if (len(args := {1, 2, 3}) == 3)) { - setverdict(pass); - } else { - setverdict(fail, "len(args := {1, 2, 3}) != 3"); - } + setverdict(pass); +} else { + setverdict(fail, "len(args := {1, 2, 3}) != 3"); +} } function len(in integer args...) return integer { - return lengthof(args); +return lengthof(args); } control { - execute(TC_Sem_050403_variadic_parameters_011()); +execute(TC_Sem_050403_variadic_parameters_011()); } } diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_001.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_001.ttcn index f501a8c..6fece35 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_001.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_001.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.2.1.4, Ensure the unqualified type name acts as the field name. - // @verdict pass reject +// @author TTF23 +// @purpose 1:6.2.1.4, Ensure the unqualified type name acts as the field name. +// @verdict pass reject module NegSem_06020104_embedding_fields_001 { type record of integer RoI; diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_002.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_002.ttcn index 17b0a05..3846768 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_002.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_002.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.2.1.4, Ensure embedded fields cannot be used as field names for assignment notations. - // @verdict pass reject +// @author TTF23 +// @purpose 1:6.2.1.4, Ensure embedded fields cannot be used as field names for assignment notations. +// @verdict pass reject module NegSem_06020104_embedding_fields_002 { type component GeneralComp {} @@ -17,7 +17,7 @@ const A OK := { B := { b := 1 } } const A notOK := { b := 1 } control { - execute(TC_NegSem_06020104_embedding_fields_002()); + execute(TC_NegSem_06020104_embedding_fields_002()); } } diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_001.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_001.ttcn index b17c537..7ca2876 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_001.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_001.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.2.1.4, Ensure the unqualified type name acts as the field name. - // @verdict pass accept +// @author TTF23 +// @purpose 1:6.2.1.4, Ensure the unqualified type name acts as the field name. +// @verdict pass accept module Sem_06020104_embedding_fields_001 { type component GeneralComp {} @@ -11,18 +11,17 @@ type record R { Sem_06020104_embedding_fields_001.GeneralComp } - testcase TC_Sem_06020104_embedding_fields_001() runs on GeneralComp { var R r := { - integer := 23, - R := {} + integer := 23, + R := {} } r.GeneralComp := GeneralComp.create setverdict(pass) } control { - execute(TC_Sem_06020104_embedding_fields_001()); + execute(TC_Sem_06020104_embedding_fields_001()); } } diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_002.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_002.ttcn index a2678b3..9aeb394 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_002.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_002.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.2.1.4, Ensure embedded field is promoted when its name is unique. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.2.1.4, Ensure embedded field is promoted when its name is unique. +// @verdict pass accept, ttcn3verdict:pass module Sem_06020104_embedding_fields_002 { type component GeneralComp {} @@ -27,7 +27,7 @@ testcase TC_Sem_06020104_embedding_fields_002() runs on GeneralComp { } control { - execute(TC_Sem_06020104_embedding_fields_002()); + execute(TC_Sem_06020104_embedding_fields_002()); } } diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_003.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_003.ttcn index 8a77c31..2107d1b 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_003.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_003.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.2.1.4, Ensure embedded field is promoted when its name is unique. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.2.1.4, Ensure embedded field is promoted when its name is unique. +// @verdict pass accept, ttcn3verdict:pass module Sem_06020104_embedding_fields_003 { type component GeneralComp {} @@ -31,7 +31,7 @@ testcase TC_Sem_06020104_embedding_fields_003() runs on GeneralComp { } control { - execute(TC_Sem_06020104_embedding_fields_003()); + execute(TC_Sem_06020104_embedding_fields_003()); } } diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_004.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_004.ttcn index 01203e6..2cf047d 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_004.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_004.ttcn @@ -1,11 +1,10 @@ - // @author TTF23 - // @purpose 1:6.2.1.4, Ensure embedded field is not promoted when its name is not unique. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.2.1.4, Ensure embedded field is not promoted when its name is not unique. +// @verdict pass accept, ttcn3verdict:pass module Sem_06020104_embedding_fields_004 { type component GeneralComp {} - type record A { B } @@ -32,7 +31,7 @@ testcase TC_Sem_06020104_embedding_fields_004() runs on GeneralComp { } control { - execute(TC_Sem_06020104_embedding_fields_004()); + execute(TC_Sem_06020104_embedding_fields_004()); } } diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060202_set_type_and_values/06020204_embedding_fields/Sem_06020204_embedding_fields_001.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060202_set_type_and_values/06020204_embedding_fields/Sem_06020204_embedding_fields_001.ttcn index 6bb8a60..e8d9d93 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060202_set_type_and_values/06020204_embedding_fields/Sem_06020204_embedding_fields_001.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060202_set_type_and_values/06020204_embedding_fields/Sem_06020204_embedding_fields_001.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.2.2.4, Ensure set defintion allow embedded fields - // @verdict pass accept +// @author TTF23 +// @purpose 1:6.2.2.4, Ensure set defintion allow embedded fields +// @verdict pass accept module Sem_06020204_embedding_fields_001 { type set S { diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060205_unions/06020504_embedding_fields/Sem_06020504_embedding_fields_001.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060205_unions/06020504_embedding_fields/Sem_06020504_embedding_fields_001.ttcn index 2f3a108..bb197a3 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060205_unions/06020504_embedding_fields/Sem_06020504_embedding_fields_001.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060205_unions/06020504_embedding_fields/Sem_06020504_embedding_fields_001.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.2.5.4, Ensure union defintions allow embedded fields and handle promotion correctly. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.2.5.4, Ensure union defintions allow embedded fields and handle promotion correctly. +// @verdict pass accept, ttcn3verdict:pass module Sem_06020504_embedding_fields_001 { type component GeneralComp {} @@ -36,7 +36,7 @@ testcase TC_Sem_06020504_embedding_fields_001() runs on GeneralComp { } control { - execute(TC_Sem_06020504_embedding_fields_001()); + execute(TC_Sem_06020504_embedding_fields_001()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_001.ttcn index 842eaf6..102304d 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_001.ttcn @@ -1,10 +1,10 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure ArrayDef part is omitted for variables with automatic type inference. - // @verdict pass reject +// @author TTF23 +// @purpose 1:6.5, Ensure ArrayDef part is omitted for variables with automatic type inference. +// @verdict pass reject module NegSem_0605_automatic_type_001 { function f() { - var x[2] := {1,2}; + var x[2] := {1, 2}; } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_002.ttcn index 1071a4e..9462250 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_002.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure ArrayDef part is omitted for constants with automatic type inference. - // @verdict pass reject +// @author TTF23 +// @purpose 1:6.5, Ensure ArrayDef part is omitted for constants with automatic type inference. +// @verdict pass reject module NegSem_0605_automatic_type_002 { const IP[4] := { 192, 168, 0, 1 }; diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_003.ttcn index bb7c227..2696728 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_003.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure ambiguous types are rejected. - // @verdict pass reject +// @author TTF23 +// @purpose 1:6.5, Ensure ambiguous types are rejected. +// @verdict pass reject module NegSem_0605_automatic_type_003 { const X := null; diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_expressions_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_expressions_001.ttcn index 9bb1d9e..215c597 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_expressions_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_expressions_001.ttcn @@ -12,7 +12,7 @@ testcase TC_NegSem_0605_expressions_001() runs on GeneralComp { } control { - execute(TC_NegSem_0605_expressions_001()); + execute(TC_NegSem_0605_expressions_001()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_index_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_index_lists_001.ttcn index f56c06f..c2c3986 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_index_lists_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_index_lists_001.ttcn @@ -10,7 +10,7 @@ testcase TC_NegSem_0605_index_lists_001() runs on GeneralComp { } control { - execute(TC_NegSem_0605_index_lists_001()); + execute(TC_NegSem_0605_index_lists_001()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_001.ttcn index 7a75180..31c3a14 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_001.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for *. - // @verdict pass reject +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for *. +// @verdict pass reject module NegSem_0605_literals_001 { modulepar template mpar := *; diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_002.ttcn index d5e49f4..28c3672 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_002.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for ?. - // @verdict pass reject +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for ?. +// @verdict pass reject module NegSem_0605_literals_002 { modulepar template mpar := ? diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_references_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_references_001.ttcn index 89a4403..7efff3a 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_references_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_references_001.ttcn @@ -12,7 +12,7 @@ testcase TC_NegSem_0605_references_001() runs on GeneralComp { } control { - execute(TC_NegSem_0605_references_001()); + execute(TC_NegSem_0605_references_001()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_001.ttcn index f31b8bb..ed55c82 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_001.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure variables provide automatic type inference. - // @verdict pass accept +// @author TTF23 +// @purpose 1:6.5, Ensure variables provide automatic type inference. +// @verdict pass accept module Sem_0605_automatic_type_001 { function f() { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_002.ttcn index 6c269b4..9e01718 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_002.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure template variables provide automatic type inference. - // @verdict pass accept +// @author TTF23 +// @purpose 1:6.5, Ensure template variables provide automatic type inference. +// @verdict pass accept module Sem_0605_automatic_type_002 { function f() { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_003.ttcn index 42f8f1b..f2ff515 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_003.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure constants provide automatic type inference. - // @verdict pass accept +// @author TTF23 +// @purpose 1:6.5, Ensure constants provide automatic type inference. +// @verdict pass accept module Sem_0605_automatic_type_003 { const X := 23; diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_004.ttcn index 81fb798..6b77281 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_004.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_004.ttcn @@ -1,11 +1,10 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure fuzzy variables provide automatic type inference. - // @verdict pass accept +// @author TTF23 +// @purpose 1:6.5, Ensure fuzzy variables provide automatic type inference. +// @verdict pass accept module Sem_0605_automatic_type_004 { function f() { var @fuzzy x := 1; } - } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_005.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_005.ttcn index 07d73a9..a94101e 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_005.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_005.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure module parameter provide automatic type inference. - // @verdict pass accept +// @author TTF23 +// @purpose 1:6.5, Ensure module parameter provide automatic type inference. +// @verdict pass accept module Sem_0605_automatic_type_005 { modulepar mpar := 1; diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_001.ttcn index 8e6dbd4..454139f 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_001.ttcn @@ -15,7 +15,7 @@ testcase TC_Sem_0605_expressions_001() runs on GeneralComp { } control { - execute(TC_Sem_0605_expressions_001()); + execute(TC_Sem_0605_expressions_001()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_002.ttcn index 7c6062b..843d81b 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_002.ttcn @@ -18,7 +18,7 @@ testcase TC_Sem_0605_expressions_002() runs on GeneralComp { } control { - execute(TC_Sem_0605_expressions_002()); + execute(TC_Sem_0605_expressions_002()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_003.ttcn index 4c9f177..f0f10ba 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_003.ttcn @@ -15,7 +15,7 @@ testcase TC_Sem_0605_expressions_003() runs on GeneralComp { } control { - execute(TC_Sem_0605_expressions_003()); + execute(TC_Sem_0605_expressions_003()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_004.ttcn index 94c287a..411b016 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_004.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_004.ttcn @@ -15,7 +15,7 @@ testcase TC_Sem_0605_expressions_004() runs on GeneralComp { } control { - execute(TC_Sem_0605_expressions_004()); + execute(TC_Sem_0605_expressions_004()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_001.ttcn index 945ef92..8e01852 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_001.ttcn @@ -20,7 +20,7 @@ testcase TC_Sem_0605_field_assignment_lists_001() runs on GeneralComp { } control { - execute(TC_Sem_0605_field_assignment_lists_001()); + execute(TC_Sem_0605_field_assignment_lists_001()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_002.ttcn index 0e5c259..66103ef 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_002.ttcn @@ -20,7 +20,7 @@ testcase TC_Sem_0605_field_assignment_lists_002() runs on GeneralComp { } control { - execute(TC_Sem_0605_field_assignment_lists_002()); + execute(TC_Sem_0605_field_assignment_lists_002()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_003.ttcn index 638321d..6d00623 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_003.ttcn @@ -15,7 +15,7 @@ testcase TC_Sem_0605_field_assignment_lists_003() runs on GeneralComp { } control { - execute(TC_Sem_0605_field_assignment_lists_003()); + execute(TC_Sem_0605_field_assignment_lists_003()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_001.ttcn index 1b901ee..1f815bd 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_001.ttcn @@ -13,7 +13,7 @@ testcase TC_Sem_0605_index_lists_001() runs on GeneralComp { } control { - execute(TC_Sem_0605_index_lists_001()); + execute(TC_Sem_0605_index_lists_001()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_002.ttcn index 034166a..75d6683 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_002.ttcn @@ -13,7 +13,7 @@ testcase TC_Sem_0605_index_lists_002() runs on GeneralComp { } control { - execute(TC_Sem_0605_index_lists_002()); + execute(TC_Sem_0605_index_lists_002()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_003.ttcn index 2894051..c313136 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_003.ttcn @@ -13,7 +13,7 @@ testcase TC_Sem_0605_index_lists_003() runs on GeneralComp { } control { - execute(TC_Sem_0605_index_lists_003()); + execute(TC_Sem_0605_index_lists_003()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_001.ttcn index 17366cb..f463b18 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_001.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for integer literals. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for integer literals. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_001 { type component GeneralComp {} @@ -12,12 +12,12 @@ function verifyType(inout integer i) { testcase TC_Sem_0605_literals_001() runs on GeneralComp { { var v := -1; verifyType(i) } - { var v := 0; verifyType(i) } - { var v := 2; verifyType(i) } + { var v := 0; verifyType(i) } + { var v := 2; verifyType(i) } } control { - execute(TC_Sem_0605_literals_001()); + execute(TC_Sem_0605_literals_001()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_002.ttcn index 59c87a8..7c5750d 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_002.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for verdicttype literals. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for verdicttype literals. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_002 { type component GeneralComp {} @@ -11,15 +11,15 @@ function verifyType(inout verdicttype v) { } testcase TC_Sem_0605_literals_002() runs on GeneralComp { - { var v := none; verifyType(v); } - { var v := pass; verifyType(v); } + { var v := none; verifyType(v); } + { var v := pass; verifyType(v); } { var v := inconc; verifyType(v); } - { var v := fail; verifyType(v); } - { var v := error; verifyType(v); } + { var v := fail; verifyType(v); } + { var v := error; verifyType(v); } } control { - execute(TC_Sem_0605_literals_002()); + execute(TC_Sem_0605_literals_002()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_003.ttcn index 1f87bf0..045a99c 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_003.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for float literals. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for float literals. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_003 { type component GeneralComp {} @@ -11,15 +11,15 @@ function verifyType(inout float f) { } testcase TC_Sem_0605_literals_003() runs on GeneralComp { - { var v := -1.0; verifyType(v) } + { var v := -1.0; verifyType(v) } { var v := not_a_number; verifyType(v) } - { var v := -infinity; verifyType(v) } - { var v := infinity; verifyType(v) } - { var v := 0.3; verifyType(v) } + { var v := -infinity; verifyType(v) } + { var v := infinity; verifyType(v) } + { var v := 0.3; verifyType(v) } } control { - execute(TC_Sem_0605_literals_003()); + execute(TC_Sem_0605_literals_003()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_004.ttcn index 0e23db1..0aa2a48 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_004.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_004.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for bitstring literals. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for bitstring literals. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_004 { type component GeneralComp {} @@ -15,7 +15,7 @@ testcase TC_Sem_0605_literals_004() runs on GeneralComp { } control { - execute(TC_Sem_0605_literals_004()); + execute(TC_Sem_0605_literals_004()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_005.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_005.ttcn index 44ac10b..6c53ca6 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_005.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_005.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for hexstring literals. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for hexstring literals. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_005 { type component GeneralComp {} @@ -15,7 +15,7 @@ testcase TC_Sem_0605_literals_005() runs on GeneralComp { } control { - execute(TC_Sem_0605_literals_005()); + execute(TC_Sem_0605_literals_005()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_006.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_006.ttcn index 4b48839..fea3e64 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_006.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_006.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for octetstring literals. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for octetstring literals. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_006 { type component GeneralComp {} @@ -15,7 +15,7 @@ testcase TC_Sem_0605_literals_006() runs on GeneralComp { } control { - execute(TC_Sem_0605_literals_006()); + execute(TC_Sem_0605_literals_006()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_007.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_007.ttcn index c248959..21e248d 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_007.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_007.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for charstring literals. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for charstring literals. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_007 { type component GeneralComp {} @@ -11,13 +11,13 @@ function verifyType(inout charstring cs) { } testcase TC_Sem_0605_literals_007() runs on GeneralComp { - { var v := ""; verifyType(v) } - { var v := "abc"; verifyType(v) } + { var v := ""; verifyType(v) } + { var v := "abc"; verifyType(v) } { var v := __MODULE__; verifyType(v) } } control { - execute(TC_Sem_0605_literals_007()); + execute(TC_Sem_0605_literals_007()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_008.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_008.ttcn index eece987..d96142b 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_008.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_008.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for universal charstring literals. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for universal charstring literals. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_008 { type component GeneralComp {} @@ -15,7 +15,7 @@ testcase TC_Sem_0605_literals_008() runs on GeneralComp { } control { - execute(TC_Sem_0605_literals_008()); + execute(TC_Sem_0605_literals_008()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_009.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_009.ttcn index 03cef66..364e8f8 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_009.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_009.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for boolean literals. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for boolean literals. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_009 { type component GeneralComp {} @@ -11,12 +11,12 @@ function verifyType(inout boolean b) { } testcase TC_Sem_0605_literals_009() runs on GeneralComp { - { var v := true; verifyType(v) } + { var v := true; verifyType(v) } { var v := false; verifyType(v) } } control { - execute(TC_Sem_0605_literals_009()); + execute(TC_Sem_0605_literals_009()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_001.ttcn index a64c057..5fd41cc 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_001.ttcn @@ -18,7 +18,7 @@ testcase TC_Sem_0605_references_001() runs on GeneralComp { } control { - execute(TC_Sem_0605_references_001()); + execute(TC_Sem_0605_references_001()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_002.ttcn index bd54eeb..cbfac70 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_002.ttcn @@ -16,7 +16,7 @@ testcase TC_Sem_0605_references_002() runs on GeneralComp { } control { - execute(TC_Sem_0605_references_002()); + execute(TC_Sem_0605_references_002()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_003.ttcn index 627ef0a..2458cda 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_003.ttcn @@ -20,7 +20,7 @@ testcase TC_Sem_0605_references_003() runs on GeneralComp { } control { - execute(TC_Sem_0605_references_003()); + execute(TC_Sem_0605_references_003()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_004.ttcn index 79ced2b..5a6bdda 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_004.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_004.ttcn @@ -18,7 +18,7 @@ testcase TC_Sem_0605_references_004() runs on GeneralComp { } control { - execute(TC_Sem_0605_references_004()); + execute(TC_Sem_0605_references_004()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_005.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_005.ttcn index 6d2234d..5ea9921 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_005.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_005.ttcn @@ -17,7 +17,7 @@ testcase TC_Sem_0605_references_005() runs on GeneralComp { } control { - execute(TC_Sem_0605_references_005()); + execute(TC_Sem_0605_references_005()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_006.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_006.ttcn index c42328e..2e66a00 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_006.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_006.ttcn @@ -16,7 +16,7 @@ testcase TC_Sem_0605_references_006() runs on GeneralComp { } control { - execute(TC_Sem_0605_references_006()); + execute(TC_Sem_0605_references_006()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_007.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_007.ttcn index 31d8a41..d9fe99a 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_007.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_007.ttcn @@ -15,7 +15,7 @@ testcase TC_Sem_0605_references_007() runs on GeneralComp { } control { - execute(TC_Sem_0605_references_007()); + execute(TC_Sem_0605_references_007()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_008.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_008.ttcn index 949afee..b05de6a 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_008.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_008.ttcn @@ -19,7 +19,7 @@ testcase TC_Sem_0605_references_008() runs on GeneralComp { } control { - execute(TC_Sem_0605_references_008()); + execute(TC_Sem_0605_references_008()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_010.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_010.ttcn index ff2d289..b3224f2 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_010.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_010.ttcn @@ -18,7 +18,7 @@ testcase TC_Sem_0605_references_010() runs on GeneralComp { } control { - execute(TC_Sem_0605_references_010()); + execute(TC_Sem_0605_references_010()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_011.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_011.ttcn index 813c876..7ff1449 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_011.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_011.ttcn @@ -19,7 +19,7 @@ testcase TC_Sem_0605_references_011() runs on GeneralComp { } control { - execute(TC_Sem_0605_references_011()); + execute(TC_Sem_0605_references_011()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_012.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_012.ttcn index d1fc6e5..a58f19e 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_012.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_012.ttcn @@ -20,7 +20,7 @@ testcase TC_Sem_0605_references_012() runs on GeneralComp { } control { - execute(TC_Sem_0605_references_012()); + execute(TC_Sem_0605_references_012()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_013.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_013.ttcn index fddb2ca..64f4356 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_013.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_013.ttcn @@ -21,7 +21,7 @@ testcase TC_Sem_0605_references_013() runs on GeneralComp { } control { - execute(TC_Sem_0605_references_013()); + execute(TC_Sem_0605_references_013()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_014.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_014.ttcn index 18bc5a0..d4d4999 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_014.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_014.ttcn @@ -21,7 +21,7 @@ testcase TC_Sem_0605_references_014() runs on GeneralComp { } control { - execute(TC_Sem_0605_references_014()); + execute(TC_Sem_0605_references_014()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_001.ttcn index d3acfa7..954c826 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_001.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for user defined functions. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for user defined functions. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_001 { type component GeneralComp {} @@ -19,7 +19,7 @@ testcase TC_Sem_0605_return_values_001() runs on GeneralComp { } control { - execute(TC_Sem_0605_return_values_001()); + execute(TC_Sem_0605_return_values_001()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_002.ttcn index 6e089ab..16ac63a 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_002.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for substr. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for substr. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_002 { type component GeneralComp {} @@ -15,7 +15,7 @@ testcase TC_Sem_0605_return_values_002() runs on GeneralComp { } control { - execute(TC_Sem_0605_return_values_002()); + execute(TC_Sem_0605_return_values_002()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_003.ttcn index 71b9953..68072bc 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_003.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for valueof. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for valueof. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_003 { type component GeneralComp {} @@ -18,7 +18,7 @@ testcase TC_Sem_0605_return_values_003() runs on GeneralComp { } control { - execute(TC_Sem_0605_return_values_003()); + execute(TC_Sem_0605_return_values_003()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_004.ttcn index d68afa2..6fe060d 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_004.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_004.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for ischosen. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for ischosen. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_004 { type component GeneralComp {} @@ -14,7 +14,7 @@ testcase TC_Sem_0605_return_values_004() runs on GeneralComp { } control { - execute(TC_Sem_0605_return_values_004()); + execute(TC_Sem_0605_return_values_004()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_005.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_005.ttcn index 88e2b4e..e3b6243 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_005.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_005.ttcn @@ -1,19 +1,19 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for match. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for match. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_005 { type component GeneralComp {} testcase TC_Sem_0605_return_values_005() runs on GeneralComp { var v := match(23, integer:(); - if (v) { - setverdict(pass); + if (v) { + setverdict(pass); + } } -} -control { - execute(TC_Sem_0605_return_values_005()); -} + control { + execute(TC_Sem_0605_return_values_005()); + } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_006.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_006.ttcn index dd29057..35e5d18 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_006.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_006.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for execute. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for execute. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_006 { type component GeneralComp {} @@ -14,8 +14,8 @@ testcase TC_Sem_0605_return_values_006_dummy() runs on GeneralComp { } control { - var v := execute(TC_Sem_0605_return_values_006_dummy()); - execute(TC_Sem_0605_return_values_006(v)); + var v := execute(TC_Sem_0605_return_values_006_dummy()); + execute(TC_Sem_0605_return_values_006(v)); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_007.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_007.ttcn index 9d3dc67..7e2b6ca 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_007.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_007.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for create. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for create. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_007 { type component GeneralComp {} @@ -15,7 +15,7 @@ testcase TC_Sem_0605_return_values_007() runs on GeneralComp { } control { - execute(TC_Sem_0605_return_values_007()); + execute(TC_Sem_0605_return_values_007()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_008.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_008.ttcn index 0dce6fc..0dcf601 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_008.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_008.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for patterns. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for patterns. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_008 { type component GeneralComp {} @@ -15,7 +15,7 @@ testcase TC_Sem_0605_return_values_008() runs on GeneralComp { } control { - execute(TC_Sem_0605_return_values_008()); + execute(TC_Sem_0605_return_values_008()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_009.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_009.ttcn index 6da3d4b..41f6c22 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_009.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_009.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for extension. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for extension. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_009 { type component GeneralComp {} @@ -8,7 +8,6 @@ type component GeneralComp {} type integer int with { extension "ext" } type record of universal charstring RoS; - testcase TC_Sem_0605_return_values_009() runs on GeneralComp { var v := int.extension; var Ros expected := { "ext" }; @@ -18,7 +17,7 @@ testcase TC_Sem_0605_return_values_009() runs on GeneralComp { } control { - execute(TC_Sem_0605_return_values_009()); + execute(TC_Sem_0605_return_values_009()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_010.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_010.ttcn index 46c4fa0..6de4802 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_010.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_010.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:6.5, Ensure automatic type for activate. - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:6.5, Ensure automatic type for activate. +// @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_009 { type component GeneralComp {} @@ -13,7 +13,7 @@ testcase TC_Sem_0605_return_values_009() runs on GeneralComp { } control { - execute(TC_Sem_0605_return_values_009()); + execute(TC_Sem_0605_return_values_009()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_001.ttcn index 47a516e..9d5cdae 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_001.ttcn @@ -9,7 +9,7 @@ testcase TC_Sem_0605_value_lists_001() runs on GeneralComp { var a := 1; var b := {a, 2}; var c := {{}, b, {3}}; - if (match(c, {{}, {1,2}, {3}})) { + if (match(c, {{}, {1, 2}, {3}})) { setverdict(pass); } else { setverdict(fail); @@ -17,7 +17,7 @@ testcase TC_Sem_0605_value_lists_001() runs on GeneralComp { } control { - execute(TC_Sem_0605_value_lists_001()); + execute(TC_Sem_0605_value_lists_001()); } } diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_002.ttcn index ee8aaf2..98564d6 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_002.ttcn @@ -15,7 +15,7 @@ testcase TC_Sem_0605_value_lists_002() runs on GeneralComp { } control { - execute(TC_Sem_0605_value_lists_002()); + execute(TC_Sem_0605_value_lists_002()); } } diff --git a/ATS/core_language/08_modules/0802_module_definitions_part/080201_module_parameters/Sem_080201_nested_types_001.ttcn b/ATS/core_language/08_modules/0802_module_definitions_part/080201_module_parameters/Sem_080201_nested_types_001.ttcn index aeaf8a2..e70d2cb 100644 --- a/ATS/core_language/08_modules/0802_module_definitions_part/080201_module_parameters/Sem_080201_nested_types_001.ttcn +++ b/ATS/core_language/08_modules/0802_module_definitions_part/080201_module_parameters/Sem_080201_nested_types_001.ttcn @@ -3,7 +3,7 @@ // @verdict pass accept module Sem_080201_nested_types_001 { -modulepar record of charstring IDs := {1,2,3}; +modulepar record of charstring IDs := {1, 2, 3}; type component GeneralComp {} @@ -12,7 +12,7 @@ testcase TC_Sem_080201_nested_types_001() runs on GeneralComp { } control { - execute(TC_Sem_080201_nested_types_001()); + execute(TC_Sem_080201_nested_types_001()); } } diff --git a/ATS/core_language/10_constants/Sem_10_nested_types_001.ttcn b/ATS/core_language/10_constants/Sem_10_nested_types_001.ttcn index 2526848..ce8510e 100644 --- a/ATS/core_language/10_constants/Sem_10_nested_types_001.ttcn +++ b/ATS/core_language/10_constants/Sem_10_nested_types_001.ttcn @@ -3,7 +3,7 @@ // @verdict pass accept module Sem_10_nested_types_001 { -const record of integer := { 1,2,3 }; +const record of integer := { 1, 2, 3 }; type component GeneralComp {} @@ -12,7 +12,7 @@ testcase TC_Sem_10_nested_types_001() runs on GeneralComp { } control { - execute(TC_Sem_10_nested_types_001()); + execute(TC_Sem_10_nested_types_001()); } } diff --git a/ATS/core_language/11_variables/Sem_11_nested_types_001.ttcn b/ATS/core_language/11_variables/Sem_11_nested_types_001.ttcn index 6035f2d..70b5c42 100644 --- a/ATS/core_language/11_variables/Sem_11_nested_types_001.ttcn +++ b/ATS/core_language/11_variables/Sem_11_nested_types_001.ttcn @@ -11,7 +11,7 @@ testcase TC_Sem_11_nested_types_001() runs on GeneralComp { } control { - execute(TC_Sem_11_nested_types_001()); + execute(TC_Sem_11_nested_types_001()); } } diff --git a/ATS/core_language/14_procedure_signatures/Sem_14_nested_types_001.ttcn b/ATS/core_language/14_procedure_signatures/Sem_14_nested_types_001.ttcn index b21a6fe..4070731 100644 --- a/ATS/core_language/14_procedure_signatures/Sem_14_nested_types_001.ttcn +++ b/ATS/core_language/14_procedure_signatures/Sem_14_nested_types_001.ttcn @@ -14,7 +14,7 @@ testcase TC_Sem_14_nested_types_001() runs on GeneralComp { } control { - execute(TC_Sem_14_nested_types_001()); + execute(TC_Sem_14_nested_types_001()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_000.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_000.ttcn index 08c57b4..cae4973 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_000.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_000.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure optional parameter is universal charstring - // @verdict pass accept, ttcn3verdict:error +// @author TTF23 +// @purpose 1:16.1.6, Ensure optional parameter is universal charstring +// @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_000 { type component GeneralComp {} @@ -10,7 +10,7 @@ testcase TC_NegSem_160106_the_not_implemented_function_000() runs on GeneralComp } control { - execute(TC_NegSem_160106_the_not_implemented_function_000()); + execute(TC_NegSem_160106_the_not_implemented_function_000()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_001.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_001.ttcn index f6dc2f4..b26481e 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_001.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_001.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure ??? can be used as value in local expressions - // @verdict pass accept, ttcn3verdict:error +// @author TTF23 +// @purpose 1:16.1.6, Ensure ??? can be used as value in local expressions +// @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_001 { type component GeneralComp {} @@ -10,7 +10,7 @@ testcase TC_NegSem_160106_the_not_implemented_function_001() runs on GeneralComp } control { - execute(TC_NegSem_160106_the_not_implemented_function_001()); + execute(TC_NegSem_160106_the_not_implemented_function_001()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_002.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_002.ttcn index 61f979e..87a039b 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_002.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_002.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure ??? can be used as value in any expressions - // @verdict pass accept, ttcn3verdict:error +// @author TTF23 +// @purpose 1:16.1.6, Ensure ??? can be used as value in any expressions +// @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_002 { type component GeneralComp {} @@ -10,7 +10,7 @@ testcase TC_NegSem_160106_the_not_implemented_function_002() runs on GeneralComp } control { - execute(TC_NegSem_160106_the_not_implemented_function_002()); + execute(TC_NegSem_160106_the_not_implemented_function_002()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_003.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_003.ttcn index bd49bc9..3c29082 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_003.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_003.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure ??? can be used as value in module parameters - // @verdict pass accept, ttcn3verdict:error +// @author TTF23 +// @purpose 1:16.1.6, Ensure ??? can be used as value in module parameters +// @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_003 { modulepar charstring reason := ???; @@ -12,7 +12,7 @@ testcase TC_NegSem_160106_the_not_implemented_function_003() runs on GeneralComp } control { - execute(TC_NegSem_160106_the_not_implemented_function_003()); + execute(TC_NegSem_160106_the_not_implemented_function_003()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_004.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_004.ttcn index 233f6da..4712591 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_004.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_004.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure ??? can be used as value as default parameter - // @verdict pass accept, ttcn3verdict:error +// @author TTF23 +// @purpose 1:16.1.6, Ensure ??? can be used as value as default parameter +// @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_004 { type component GeneralComp {} @@ -17,7 +17,7 @@ testcase TC_NegSem_160106_the_not_implemented_function_004() runs on GeneralComp } control { - execute(TC_NegSem_160106_the_not_implemented_function_004()); + execute(TC_NegSem_160106_the_not_implemented_function_004()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_005.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_005.ttcn index 7e66e5c..1a67ee1 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_005.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_005.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure ??? can be used as stand-alone statement (direct use) - // @verdict pass accept, ttcn3verdict:error +// @author TTF23 +// @purpose 1:16.1.6, Ensure ??? can be used as stand-alone statement (direct use) +// @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_005 { type component GeneralComp {} @@ -10,7 +10,7 @@ testcase TC_NegSem_160106_the_not_implemented_function_005() runs on GeneralComp } control { - execute(TC_NegSem_160106_the_not_implemented_function_005()); + execute(TC_NegSem_160106_the_not_implemented_function_005()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_006.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_006.ttcn index 85054c6..94b3129 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_006.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_006.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure optional parameter is universal charstring - // @verdict pass reject +// @author TTF23 +// @purpose 1:16.1.6, Ensure optional parameter is universal charstring +// @verdict pass reject module NegSem_160106_the_not_implemented_function_006 { type component GeneralComp {} @@ -11,7 +11,7 @@ testcase TC_NegSem_160106_the_not_implemented_function_006() runs on GeneralComp } control { - execute(TC_NegSem_160106_the_not_implemented_function_006()); + execute(TC_NegSem_160106_the_not_implemented_function_006()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_007.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_007.ttcn index c8cdb20..1038766 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_007.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_007.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure optional parameter is universal charstring - // @verdict pass accept, ttcn3verdict:error +// @author TTF23 +// @purpose 1:16.1.6, Ensure optional parameter is universal charstring +// @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_007 { type component GeneralComp {} @@ -10,7 +10,7 @@ testcase TC_NegSem_160106_the_not_implemented_function_007() runs on GeneralComp } control { - execute(TC_NegSem_160106_the_not_implemented_function_007()); + execute(TC_NegSem_160106_the_not_implemented_function_007()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_008.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_008.ttcn index d5af59f..b74be09 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_008.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_008.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure optional parameter is universal charstring - // @verdict pass accept, ttcn3verdict:error +// @author TTF23 +// @purpose 1:16.1.6, Ensure optional parameter is universal charstring +// @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_008 { type component GeneralComp {} @@ -10,7 +10,7 @@ testcase TC_NegSem_160106_the_not_implemented_function_008() runs on GeneralComp } control { - execute(TC_NegSem_160106_the_not_implemented_function_008()); + execute(TC_NegSem_160106_the_not_implemented_function_008()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_001.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_001.ttcn index d00081d..5e685bb 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_001.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_001.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure ??? can be used as value as default parameter - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:16.1.6, Ensure ??? can be used as value as default parameter +// @verdict pass accept, ttcn3verdict:pass module Sem_160106_the_not_implemented_function_001 { type component GeneralComp {} @@ -17,7 +17,7 @@ testcase TC_Sem_160106_the_not_implemented_function_001() runs on GeneralComp { } control { - execute(TC_Sem_160106_the_not_implemented_function_001()); + execute(TC_Sem_160106_the_not_implemented_function_001()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_002.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_002.ttcn index 5e56ae8..eb17244 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_002.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_002.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure ??? can be used as stand-alone statement (direct use) - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:16.1.6, Ensure ??? can be used as stand-alone statement (direct use) +// @verdict pass accept, ttcn3verdict:pass module Sem_160106_the_not_implemented_function_002 { type component GeneralComp {} @@ -13,7 +13,7 @@ testcase TC_Sem_160106_the_not_implemented_function_002() runs on GeneralComp { } control { - execute(TC_Sem_160106_the_not_implemented_function_002()); + execute(TC_Sem_160106_the_not_implemented_function_002()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_003.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_003.ttcn index cf92f21..570ae71 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_003.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_003.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure ??? allows optional parameter - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:16.1.6, Ensure ??? allows optional parameter +// @verdict pass accept, ttcn3verdict:pass module Sem_160106_the_not_implemented_function_003 { type component GeneralComp {} @@ -14,7 +14,7 @@ testcase TC_Sem_160106_the_not_implemented_function_003() runs on GeneralComp { } control { - execute(TC_Sem_160106_the_not_implemented_function_003()); + execute(TC_Sem_160106_the_not_implemented_function_003()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_004.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_004.ttcn index d922547..e70dfa1 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_004.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_004.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure optional parameter is universal charstring - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:16.1.6, Ensure optional parameter is universal charstring +// @verdict pass accept, ttcn3verdict:pass module Sem_160106_the_not_implemented_function_004 { type component GeneralComp {} @@ -13,7 +13,7 @@ testcase TC_Sem_160106_the_not_implemented_function_004() runs on GeneralComp { } control { - execute(TC_Sem_160106_the_not_implemented_function_004()); + execute(TC_Sem_160106_the_not_implemented_function_004()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_005.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_005.ttcn index 94d50cc..6a590db 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_005.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_005.ttcn @@ -1,6 +1,6 @@ - // @author TTF23 - // @purpose 1:16.1.6, Ensure implementation does not change during tests execution - // @verdict pass accept, ttcn3verdict:pass +// @author TTF23 +// @purpose 1:16.1.6, Ensure implementation does not change during tests execution +// @verdict pass accept, ttcn3verdict:pass module Sem_160106_the_not_implemented_function_005 { type component GeneralComp {} @@ -20,7 +20,7 @@ testcase TC_Sem_160106_the_not_implemented_function_005() runs on GeneralComp { } control { - execute(TC_Sem_160106_the_not_implemented_function_005()); + execute(TC_Sem_160106_the_not_implemented_function_005()); } } diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/1601_toplevel/Sem_1601_nested_types_001.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/1601_toplevel/Sem_1601_nested_types_001.ttcn index d2b835a..137129a 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/1601_toplevel/Sem_1601_nested_types_001.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/1601_toplevel/Sem_1601_nested_types_001.ttcn @@ -14,7 +14,7 @@ testcase TC_Sem_1601_nested_types_001() runs on GeneralComp { } control { - execute(TC_Sem_1601_nested_types_001()); + execute(TC_Sem_1601_nested_types_001()); } } -- GitLab From b60dac046460fe660e6158ee12886a1d93d55c71 Mon Sep 17 00:00:00 2001 From: Matthias Simon Date: Thu, 6 Apr 2023 10:57:24 +0200 Subject: [PATCH 14/14] Fix author tags --- .../Sem_05040101_nested_types_001.ttcn | 2 +- .../Sem_05040102_nested_types_001.ttcn | 2 +- .../NegSem_050403_variadic_parameters_001.ttcn | 2 +- .../NegSem_050403_variadic_parameters_002.ttcn | 2 +- .../NegSem_050403_variadic_parameters_003.ttcn | 2 +- .../NegSem_050403_variadic_parameters_004.ttcn | 2 +- .../NegSem_050403_variadic_parameters_005.ttcn | 2 +- .../Sem_050403_variadic_parameters_001.ttcn | 2 +- .../Sem_050403_variadic_parameters_002.ttcn | 2 +- .../Sem_050403_variadic_parameters_003.ttcn | 2 +- .../Sem_050403_variadic_parameters_004.ttcn | 2 +- .../Sem_050403_variadic_parameters_005.ttcn | 2 +- .../Sem_050403_variadic_parameters_006.ttcn | 2 +- .../Sem_050403_variadic_parameters_007.ttcn | 2 +- .../Sem_050403_variadic_parameters_008.ttcn | 2 +- .../Sem_050403_variadic_parameters_009.ttcn | 2 +- .../Sem_050403_variadic_parameters_010.ttcn | 2 +- .../Sem_050403_variadic_parameters_011.ttcn | 2 +- .../NegSem_06020104_embedding_fields_001.ttcn | 2 +- .../NegSem_06020104_embedding_fields_002.ttcn | 2 +- .../Sem_06020104_embedding_fields_001.ttcn | 2 +- .../Sem_06020104_embedding_fields_002.ttcn | 2 +- .../Sem_06020104_embedding_fields_003.ttcn | 2 +- .../Sem_06020104_embedding_fields_004.ttcn | 2 +- .../Sem_06020204_embedding_fields_001.ttcn | 2 +- .../Sem_06020504_embedding_fields_001.ttcn | 2 +- .../0605_automatic_type/NegSem_0605_automatic_type_001.ttcn | 2 +- .../0605_automatic_type/NegSem_0605_automatic_type_002.ttcn | 2 +- .../0605_automatic_type/NegSem_0605_automatic_type_003.ttcn | 2 +- .../0605_automatic_type/NegSem_0605_expressions_001.ttcn | 2 +- .../0605_automatic_type/NegSem_0605_index_lists_001.ttcn | 2 +- .../0605_automatic_type/NegSem_0605_literals_001.ttcn | 2 +- .../0605_automatic_type/NegSem_0605_literals_002.ttcn | 2 +- .../0605_automatic_type/NegSem_0605_references_001.ttcn | 2 +- .../0605_automatic_type/Sem_0605_automatic_type_001.ttcn | 2 +- .../0605_automatic_type/Sem_0605_automatic_type_002.ttcn | 2 +- .../0605_automatic_type/Sem_0605_automatic_type_003.ttcn | 2 +- .../0605_automatic_type/Sem_0605_automatic_type_004.ttcn | 2 +- .../0605_automatic_type/Sem_0605_automatic_type_005.ttcn | 2 +- .../0605_automatic_type/Sem_0605_expressions_001.ttcn | 2 +- .../0605_automatic_type/Sem_0605_expressions_002.ttcn | 2 +- .../0605_automatic_type/Sem_0605_expressions_003.ttcn | 2 +- .../0605_automatic_type/Sem_0605_expressions_004.ttcn | 2 +- .../Sem_0605_field_assignment_lists_001.ttcn | 2 +- .../Sem_0605_field_assignment_lists_002.ttcn | 2 +- .../Sem_0605_field_assignment_lists_003.ttcn | 2 +- .../0605_automatic_type/Sem_0605_index_lists_001.ttcn | 2 +- .../0605_automatic_type/Sem_0605_index_lists_002.ttcn | 2 +- .../0605_automatic_type/Sem_0605_index_lists_003.ttcn | 2 +- .../0605_automatic_type/Sem_0605_literals_001.ttcn | 2 +- .../0605_automatic_type/Sem_0605_literals_002.ttcn | 2 +- .../0605_automatic_type/Sem_0605_literals_003.ttcn | 2 +- .../0605_automatic_type/Sem_0605_literals_004.ttcn | 2 +- .../0605_automatic_type/Sem_0605_literals_005.ttcn | 2 +- .../0605_automatic_type/Sem_0605_literals_006.ttcn | 2 +- .../0605_automatic_type/Sem_0605_literals_007.ttcn | 2 +- .../0605_automatic_type/Sem_0605_literals_008.ttcn | 2 +- .../0605_automatic_type/Sem_0605_literals_009.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_001.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_002.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_003.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_004.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_005.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_006.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_007.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_008.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_009.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_010.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_011.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_012.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_013.ttcn | 2 +- .../0605_automatic_type/Sem_0605_references_014.ttcn | 2 +- .../0605_automatic_type/Sem_0605_return_values_001.ttcn | 2 +- .../0605_automatic_type/Sem_0605_return_values_002.ttcn | 2 +- .../0605_automatic_type/Sem_0605_return_values_003.ttcn | 2 +- .../0605_automatic_type/Sem_0605_return_values_004.ttcn | 2 +- .../0605_automatic_type/Sem_0605_return_values_005.ttcn | 2 +- .../0605_automatic_type/Sem_0605_return_values_006.ttcn | 2 +- .../0605_automatic_type/Sem_0605_return_values_007.ttcn | 2 +- .../0605_automatic_type/Sem_0605_return_values_008.ttcn | 2 +- .../0605_automatic_type/Sem_0605_return_values_009.ttcn | 2 +- .../0605_automatic_type/Sem_0605_return_values_010.ttcn | 2 +- .../0605_automatic_type/Sem_0605_value_lists_001.ttcn | 2 +- .../0605_automatic_type/Sem_0605_value_lists_002.ttcn | 2 +- .../080201_module_parameters/Sem_080201_nested_types_001.ttcn | 2 +- ATS/core_language/10_constants/Sem_10_nested_types_001.ttcn | 2 +- ATS/core_language/11_variables/Sem_11_nested_types_001.ttcn | 2 +- .../14_procedure_signatures/Sem_14_nested_types_001.ttcn | 2 +- .../NegSem_160106_the_not_implemented_function_000.ttcn | 2 +- .../NegSem_160106_the_not_implemented_function_001.ttcn | 2 +- .../NegSem_160106_the_not_implemented_function_002.ttcn | 2 +- .../NegSem_160106_the_not_implemented_function_003.ttcn | 2 +- .../NegSem_160106_the_not_implemented_function_004.ttcn | 2 +- .../NegSem_160106_the_not_implemented_function_005.ttcn | 2 +- .../NegSem_160106_the_not_implemented_function_006.ttcn | 2 +- .../NegSem_160106_the_not_implemented_function_007.ttcn | 2 +- .../NegSem_160106_the_not_implemented_function_008.ttcn | 2 +- .../Sem_160106_the_not_implemented_function_001.ttcn | 2 +- .../Sem_160106_the_not_implemented_function_002.ttcn | 2 +- .../Sem_160106_the_not_implemented_function_003.ttcn | 2 +- .../Sem_160106_the_not_implemented_function_004.ttcn | 2 +- .../Sem_160106_the_not_implemented_function_005.ttcn | 2 +- .../1601_functions/1601_toplevel/Sem_1601_nested_types_001.ttcn | 2 +- 103 files changed, 103 insertions(+), 103 deletions(-) diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040101_parameters_of_kind_value/Sem_05040101_nested_types_001.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040101_parameters_of_kind_value/Sem_05040101_nested_types_001.ttcn index d58609f..6d722b1 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040101_parameters_of_kind_value/Sem_05040101_nested_types_001.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040101_parameters_of_kind_value/Sem_05040101_nested_types_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.1.1, Ensure formal parameters accept nested types. // @verdict pass accept module Sem_05040101_nested_types_001 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040102_parameters_of_kind_template/Sem_05040102_nested_types_001.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040102_parameters_of_kind_template/Sem_05040102_nested_types_001.ttcn index 35823ff..1fa8e40 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040102_parameters_of_kind_template/Sem_05040102_nested_types_001.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050401_formal_parameters/05040102_parameters_of_kind_template/Sem_05040102_nested_types_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.1.2, Ensure formal parameters accept nested types. // @verdict pass accept module Sem_05040102_nested_types_001 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_001.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_001.ttcn index e0dffe8..abab8f1 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_001.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure variadic formal parameters are at the end of the formal parameter list. // @verdict pass reject module NegSem_050403_variadic_parameters_001 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_002.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_002.ttcn index c1ce1c2..d32b3fc 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_002.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure only one variadic formal parameter per formal parameter list is allowed. // @verdict pass reject module NegSem_050403_variadic_parameters_002 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_003.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_003.ttcn index 663e67e..8fe75be 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_003.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_003.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure variadic parameters are in parameters. // @verdict pass reject module NegSem_050403_variadic_parameters_003 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_004.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_004.ttcn index 6a9ed74..c5f9a65 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_004.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_004.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure actual variadic parameter results in an equivalent record of in their declaration order. // @verdict pass reject module NegSem_050403_variadic_parameters_004 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_005.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_005.ttcn index 85b43c8..f3dd69e 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_005.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/NegSem_050403_variadic_parameters_005.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure an actual record of parameter in assignment notation has no additional ellipsis. // @verdict pass reject module NegSem_050403_variadic_parameters_005 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_001.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_001.ttcn index 8af5c63..73ea802 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_001.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure template definitions support variadic formal parameters. // @verdict pass accept module Sem_050403_variadic_parameters_001 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_002.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_002.ttcn index 0c6131a..5c849b4 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_002.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure function definitions support variadic formal parameters. // @verdict pass accept module Sem_050403_variadic_parameters_002 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_003.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_003.ttcn index b13dd0a..c6f9d2d 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_003.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_003.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure altstep definitions support variadic formal parameters. // @verdict pass accept module Sem_050403_variadic_parameters_003 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_004.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_004.ttcn index 4bfea63..db03707 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_004.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_004.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure testcase definitions support variadic formal parameters. // @verdict pass accept, testverdict:pass module Sem_050403_variadic_parameters_004 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_005.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_005.ttcn index a7b2d2d..8d0c0ed 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_005.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_005.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure variadic formal parameters may have default values. // @verdict pass accept module Sem_050403_variadic_parameters_005 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_006.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_006.ttcn index 69ed97d..e337874 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_006.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_006.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure variadic parameters are visible as record of types inside the defintion. // @verdict pass accept module Sem_050403_variadic_parameters_006 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_007.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_007.ttcn index 5196976..4f682d8 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_007.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_007.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure omitted variadic parameter results in an empty record of. // @verdict pass accept, ttcn3verdict:pass module Sem_050403_variadic_parameters_007 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_008.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_008.ttcn index a3d0c7c..52ac616 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_008.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_008.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure unused variadic parameter results in an empty record of. // @verdict pass accept, ttcn3verdict:pass module Sem_050403_variadic_parameters_008 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_009.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_009.ttcn index ec902ca..a9c14c6 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_009.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_009.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure actual variadic parameter results in an equivalent record of in their declaration order. // @verdict pass accept, ttcn3verdict:pass module Sem_050403_variadic_parameters_009 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_010.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_010.ttcn index a65e3be..eb04382 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_010.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_010.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure an actual record of parameter with ... is passed directly to the formal variadic parameter. // @verdict pass accept, ttcn3verdict:pass module Sem_050403_variadic_parameters_010 { diff --git a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_011.ttcn b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_011.ttcn index 00b5554..89e1568 100644 --- a/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_011.ttcn +++ b/ATS/core_language/05_basic_language_elements/0504_parametrization/050403_variadic_parameters/Sem_050403_variadic_parameters_011.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:5.4.3, Ensure an actual record of parameter in assignment notation is passed directly to the formal variadic parameter. // @verdict pass accept, ttcn3verdict:pass module Sem_050403_variadic_parameters_011 { diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_001.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_001.ttcn index 6fece35..4f477a3 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_001.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.2.1.4, Ensure the unqualified type name acts as the field name. // @verdict pass reject module NegSem_06020104_embedding_fields_001 { diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_002.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_002.ttcn index 3846768..ddcee9f 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_002.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/NegSem_06020104_embedding_fields_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.2.1.4, Ensure embedded fields cannot be used as field names for assignment notations. // @verdict pass reject module NegSem_06020104_embedding_fields_002 { diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_001.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_001.ttcn index 7ca2876..057bea8 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_001.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.2.1.4, Ensure the unqualified type name acts as the field name. // @verdict pass accept module Sem_06020104_embedding_fields_001 { diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_002.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_002.ttcn index 9aeb394..5a70ee2 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_002.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.2.1.4, Ensure embedded field is promoted when its name is unique. // @verdict pass accept, ttcn3verdict:pass module Sem_06020104_embedding_fields_002 { diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_003.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_003.ttcn index 2107d1b..208e515 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_003.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_003.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.2.1.4, Ensure embedded field is promoted when its name is unique. // @verdict pass accept, ttcn3verdict:pass module Sem_06020104_embedding_fields_003 { diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_004.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_004.ttcn index 2cf047d..338df9b 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_004.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060201_record_type_and_values/06020104_embedding_fields/Sem_06020104_embedding_fields_004.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.2.1.4, Ensure embedded field is not promoted when its name is not unique. // @verdict pass accept, ttcn3verdict:pass module Sem_06020104_embedding_fields_004 { diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060202_set_type_and_values/06020204_embedding_fields/Sem_06020204_embedding_fields_001.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060202_set_type_and_values/06020204_embedding_fields/Sem_06020204_embedding_fields_001.ttcn index e8d9d93..f97b500 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060202_set_type_and_values/06020204_embedding_fields/Sem_06020204_embedding_fields_001.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060202_set_type_and_values/06020204_embedding_fields/Sem_06020204_embedding_fields_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.2.2.4, Ensure set defintion allow embedded fields // @verdict pass accept module Sem_06020204_embedding_fields_001 { diff --git a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060205_unions/06020504_embedding_fields/Sem_06020504_embedding_fields_001.ttcn b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060205_unions/06020504_embedding_fields/Sem_06020504_embedding_fields_001.ttcn index bb197a3..177e168 100644 --- a/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060205_unions/06020504_embedding_fields/Sem_06020504_embedding_fields_001.ttcn +++ b/ATS/core_language/06_types_and_values/0602_structured_types_and_values/060205_unions/06020504_embedding_fields/Sem_06020504_embedding_fields_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.2.5.4, Ensure union defintions allow embedded fields and handle promotion correctly. // @verdict pass accept, ttcn3verdict:pass module Sem_06020504_embedding_fields_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_001.ttcn index 102304d..81e0df4 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure ArrayDef part is omitted for variables with automatic type inference. // @verdict pass reject module NegSem_0605_automatic_type_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_002.ttcn index 9462250..5960344 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure ArrayDef part is omitted for constants with automatic type inference. // @verdict pass reject module NegSem_0605_automatic_type_002 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_003.ttcn index 2696728..565fab3 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_automatic_type_003.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure ambiguous types are rejected. // @verdict pass reject module NegSem_0605_automatic_type_003 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_expressions_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_expressions_001.ttcn index 215c597..f8cefed 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_expressions_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_expressions_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure qualified enumerated values. // @verdict pass reject module NegSem_0605_expressions_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_index_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_index_lists_001.ttcn index c2c3986..b76bdd2 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_index_lists_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_index_lists_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure index list with common key type keys is a map. // @verdict pass reject module NegSem_0605_index_lists_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_001.ttcn index 31c3a14..5b0ad4c 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for *. // @verdict pass reject module NegSem_0605_literals_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_002.ttcn index 28c3672..f02061d 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_literals_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for ?. // @verdict pass reject module NegSem_0605_literals_002 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_references_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_references_001.ttcn index 7efff3a..7aa61f2 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_references_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/NegSem_0605_references_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for templates. // @verdict pass reject module NegSem_0605_references_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_001.ttcn index ed55c82..befc6e5 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure variables provide automatic type inference. // @verdict pass accept module Sem_0605_automatic_type_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_002.ttcn index 9e01718..2146a2a 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure template variables provide automatic type inference. // @verdict pass accept module Sem_0605_automatic_type_002 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_003.ttcn index f2ff515..85067f8 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_003.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure constants provide automatic type inference. // @verdict pass accept module Sem_0605_automatic_type_003 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_004.ttcn index 6b77281..b77892a 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_004.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_004.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure fuzzy variables provide automatic type inference. // @verdict pass accept module Sem_0605_automatic_type_004 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_005.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_005.ttcn index a94101e..44a8817 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_005.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_automatic_type_005.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure module parameter provide automatic type inference. // @verdict pass accept module Sem_0605_automatic_type_005 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_001.ttcn index 454139f..0613210 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for expressions. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_expressions_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_002.ttcn index 843d81b..2629a4f 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure qualified enumerated values. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_expressions_002 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_003.ttcn index f0f10ba..8444057 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_003.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for value ranges. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_expressions_003 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_004.ttcn index 411b016..eabe4a8 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_004.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_expressions_004.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure infinity bounds are inferred to integer. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_expressions_004 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_001.ttcn index 8e01852..4b50c62 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure record fields have the same order as specified. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_field_assignment_lists_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_002.ttcn index 66103ef..74b8f86 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure record fields become optional as specified (15.8). // @verdict pass accept, ttcn3verdict:pass module Sem_0605_field_assignment_lists_002 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_003.ttcn index 6d00623..aa4917b 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_field_assignment_lists_003.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure field assignment lists are anonymous records. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_field_assignment_lists_003 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_001.ttcn index 1f815bd..b88cebe 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure index list with integer key type is a record of. // @verdict pass accept module Sem_0605_index_lists_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_002.ttcn index 75d6683..aecfb7a 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure index list with common key type keys is a map. // @verdict pass accept module Sem_0605_index_lists_002 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_003.ttcn index c313136..0e924f4 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_index_lists_003.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure index list with common key type keys is a map. // @verdict pass accept module Sem_0605_index_lists_003 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_001.ttcn index f463b18..d2169c6 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for integer literals. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_002.ttcn index 7c5750d..a503100 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for verdicttype literals. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_002 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_003.ttcn index 045a99c..531d7ad 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_003.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for float literals. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_003 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_004.ttcn index 0aa2a48..d7d27a6 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_004.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_004.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for bitstring literals. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_004 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_005.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_005.ttcn index 6c53ca6..e52c4b4 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_005.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_005.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for hexstring literals. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_005 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_006.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_006.ttcn index fea3e64..10ac407 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_006.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_006.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for octetstring literals. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_006 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_007.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_007.ttcn index 21e248d..8a8502a 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_007.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_007.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for charstring literals. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_007 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_008.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_008.ttcn index d96142b..c6eea74 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_008.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_008.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for universal charstring literals. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_008 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_009.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_009.ttcn index 364e8f8..a6ac52f 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_009.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_literals_009.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for boolean literals. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_literals_009 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_001.ttcn index 5fd41cc..30d2447 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for variables. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_references_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_002.ttcn index cbfac70..632ec8e 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for arrays. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_references_002 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_003.ttcn index 2458cda..21e818c 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_003.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for lazy variables. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_references_003 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_004.ttcn index 5a6bdda..ab5b003 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_004.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_004.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for module parameter references. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_references_004 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_005.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_005.ttcn index 5ea9921..a313bd5 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_005.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_005.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for templates. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_references_005 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_006.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_006.ttcn index 2e66a00..9484115 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_006.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_006.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for modified templates. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_references_006 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_007.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_007.ttcn index d9fe99a..8c98272 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_007.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_007.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for components. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_references_007 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_008.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_008.ttcn index b05de6a..8a2a889 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_008.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_008.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for ports. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_references_008 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_009.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_009.ttcn index 857ef53..327248a 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_009.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_009.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for timer. // @verdict pass accept module Sem_0605_references_009 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_010.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_010.ttcn index b3224f2..b40dd02 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_010.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_010.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for constants. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_references_010 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_011.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_011.ttcn index 7ff1449..2b60b69 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_011.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_011.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for parameters. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_references_011 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_012.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_012.ttcn index a58f19e..3211609 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_012.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_012.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for field references. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_references_012 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_013.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_013.ttcn index 64f4356..f3c8c18 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_013.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_013.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for references to unions; // @verdict pass accept, ttcn3verdict:pass module Sem_0605_references_013 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_014.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_014.ttcn index d4d4999..d7a800a 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_014.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_references_014.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for references to union default variants. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_references_014 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_001.ttcn index 954c826..3c5511b 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for user defined functions. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_002.ttcn index 16ac63a..e4ab5b7 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for substr. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_002 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_003.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_003.ttcn index 68072bc..b8cb1aa 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_003.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_003.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for valueof. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_003 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_004.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_004.ttcn index 6fe060d..4f389b4 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_004.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_004.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for ischosen. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_004 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_005.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_005.ttcn index e3b6243..98d10fe 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_005.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_005.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for match. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_005 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_006.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_006.ttcn index 35e5d18..6c7c124 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_006.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_006.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for execute. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_006 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_007.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_007.ttcn index 7e2b6ca..b45603e 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_007.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_007.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for create. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_007 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_008.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_008.ttcn index 0dcf601..cba9cc1 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_008.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_008.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for patterns. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_008 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_009.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_009.ttcn index 41f6c22..9a928c6 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_009.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_009.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for extension. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_009 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_010.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_010.ttcn index 6de4802..7c7d2a5 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_010.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_return_values_010.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure automatic type for activate. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_return_values_009 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_001.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_001.ttcn index 9d5cdae..a164f6d 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_001.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure common type of value lists is inferred. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_value_lists_001 { diff --git a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_002.ttcn b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_002.ttcn index 98564d6..b744668 100644 --- a/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_002.ttcn +++ b/ATS/core_language/06_types_and_values/0605_automatic_type/Sem_0605_value_lists_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:6.5, Ensure common type of value lists is inferred. // @verdict pass accept, ttcn3verdict:pass module Sem_0605_value_lists_002 { diff --git a/ATS/core_language/08_modules/0802_module_definitions_part/080201_module_parameters/Sem_080201_nested_types_001.ttcn b/ATS/core_language/08_modules/0802_module_definitions_part/080201_module_parameters/Sem_080201_nested_types_001.ttcn index e70d2cb..30ed012 100644 --- a/ATS/core_language/08_modules/0802_module_definitions_part/080201_module_parameters/Sem_080201_nested_types_001.ttcn +++ b/ATS/core_language/08_modules/0802_module_definitions_part/080201_module_parameters/Sem_080201_nested_types_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:8.2.1, Ensure module parameters accept nested types. // @verdict pass accept module Sem_080201_nested_types_001 { diff --git a/ATS/core_language/10_constants/Sem_10_nested_types_001.ttcn b/ATS/core_language/10_constants/Sem_10_nested_types_001.ttcn index ce8510e..6ad3a3e 100644 --- a/ATS/core_language/10_constants/Sem_10_nested_types_001.ttcn +++ b/ATS/core_language/10_constants/Sem_10_nested_types_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:10, Ensure constants accept nested types. // @verdict pass accept module Sem_10_nested_types_001 { diff --git a/ATS/core_language/11_variables/Sem_11_nested_types_001.ttcn b/ATS/core_language/11_variables/Sem_11_nested_types_001.ttcn index 70b5c42..0032fe8 100644 --- a/ATS/core_language/11_variables/Sem_11_nested_types_001.ttcn +++ b/ATS/core_language/11_variables/Sem_11_nested_types_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:11, Ensure variables accept nested types. // @verdict pass accept module Sem_11_nested_types_001 { diff --git a/ATS/core_language/14_procedure_signatures/Sem_14_nested_types_001.ttcn b/ATS/core_language/14_procedure_signatures/Sem_14_nested_types_001.ttcn index 4070731..e294581 100644 --- a/ATS/core_language/14_procedure_signatures/Sem_14_nested_types_001.ttcn +++ b/ATS/core_language/14_procedure_signatures/Sem_14_nested_types_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:14, Ensure signatures accept nested types. // @verdict pass accept module Sem_14_nested_types_001 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_000.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_000.ttcn index cae4973..7f6698e 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_000.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_000.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure optional parameter is universal charstring // @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_000 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_001.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_001.ttcn index b26481e..953f4cd 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_001.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure ??? can be used as value in local expressions // @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_001 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_002.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_002.ttcn index 87a039b..675d656 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_002.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure ??? can be used as value in any expressions // @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_002 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_003.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_003.ttcn index 3c29082..ac55d18 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_003.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_003.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure ??? can be used as value in module parameters // @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_003 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_004.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_004.ttcn index 4712591..2fbddd5 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_004.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_004.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure ??? can be used as value as default parameter // @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_004 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_005.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_005.ttcn index 1a67ee1..a524f78 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_005.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_005.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure ??? can be used as stand-alone statement (direct use) // @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_005 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_006.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_006.ttcn index 94b3129..c87d4a7 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_006.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_006.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure optional parameter is universal charstring // @verdict pass reject module NegSem_160106_the_not_implemented_function_006 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_007.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_007.ttcn index 1038766..a17ff42 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_007.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_007.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure optional parameter is universal charstring // @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_007 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_008.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_008.ttcn index b74be09..deb497e 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_008.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/NegSem_160106_the_not_implemented_function_008.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure optional parameter is universal charstring // @verdict pass accept, ttcn3verdict:error module NegSem_160106_the_not_implemented_function_008 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_001.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_001.ttcn index 5e685bb..485bf88 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_001.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure ??? can be used as value as default parameter // @verdict pass accept, ttcn3verdict:pass module Sem_160106_the_not_implemented_function_001 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_002.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_002.ttcn index eb17244..b2a46c2 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_002.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_002.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure ??? can be used as stand-alone statement (direct use) // @verdict pass accept, ttcn3verdict:pass module Sem_160106_the_not_implemented_function_002 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_003.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_003.ttcn index 570ae71..d1127db 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_003.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_003.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure ??? allows optional parameter // @verdict pass accept, ttcn3verdict:pass module Sem_160106_the_not_implemented_function_003 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_004.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_004.ttcn index e70dfa1..dbf5bb8 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_004.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_004.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure optional parameter is universal charstring // @verdict pass accept, ttcn3verdict:pass module Sem_160106_the_not_implemented_function_004 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_005.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_005.ttcn index 6a590db..7dd347c 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_005.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/160106_the_not_implemented_function/Sem_160106_the_not_implemented_function_005.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.6, Ensure implementation does not change during tests execution // @verdict pass accept, ttcn3verdict:pass module Sem_160106_the_not_implemented_function_005 { diff --git a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/1601_toplevel/Sem_1601_nested_types_001.ttcn b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/1601_toplevel/Sem_1601_nested_types_001.ttcn index 137129a..fc8edc0 100644 --- a/ATS/core_language/16_functions_altsteps_testcases/1601_functions/1601_toplevel/Sem_1601_nested_types_001.ttcn +++ b/ATS/core_language/16_functions_altsteps_testcases/1601_functions/1601_toplevel/Sem_1601_nested_types_001.ttcn @@ -1,4 +1,4 @@ -// @author TTF23 +// @author TTF T023 // @purpose 1:16.1.0, Ensure functions accept nested return types. // @verdict pass accept module Sem_1601_nested_types_001 { -- GitLab