/[svn]/linuxsampler/trunk/src/scriptvm/tests/NKSPCoreLangTest.cpp

Diff of /linuxsampler/trunk/src/scriptvm/tests/NKSPCoreLangTest.cpp

Parent Directory | Revision Log | View Patch Patch

-linuxsampler/trunk/src/scriptvm/tests/NKSPTest.cpp
revision 3581 by schoenebeck,
Fri Aug 30 11:40:25 2019 UTC
+linuxsampler/trunk/src/scriptvm/tests/NKSPCoreLangTest.cpp
revision 3790 by schoenebeck,
Sun Jun 14 14:29:41 2020 UTC
 Line 1
  /*
-  * Copyright (c) 2019 Christian Schoenebeck
+  * Copyright (c) 2019 - 2020 Christian Schoenebeck
   *
   * http://www.linuxsampler.org
   *
 Line 129 
 static void runScript(const RunScriptOpt
          if (opt.expectExitResultUnit) {
              VMExpr* resExpr = execCtx->exitResult();
              TEST_ASSERT(resExpr);
-             VMScalarNumberExpr* numberExpr = resExpr->asScalarNumberExpr();
+             VMNumberExpr* numberExpr = resExpr->asNumber();
              TEST_ASSERT(numberExpr);
              TEST_ASSERT(numberExpr->unitType() == *opt.expectExitResultUnit);
          }
          if (!opt.expectExitResultUnitPrefix.empty()) {
              VMExpr* resExpr = execCtx->exitResult();
              TEST_ASSERT(resExpr);
-             VMScalarNumberExpr* numberExpr = resExpr->asScalarNumberExpr();
+             VMNumberExpr* numberExpr = resExpr->asNumber();
              TEST_ASSERT(numberExpr);
              auto prefixes = opt.expectExitResultUnitPrefix;
              if (*prefixes.rbegin() != VM_NO_PREFIX)
 Line 152 
 static void runScript(const RunScriptOpt
          if (opt.expectExitResultFinal) {
              VMExpr* resExpr = execCtx->exitResult();
              TEST_ASSERT(resExpr);
-             VMScalarNumberExpr* numberExpr = resExpr->asScalarNumberExpr();
+             VMNumberExpr* numberExpr = resExpr->asNumber();
              TEST_ASSERT(numberExpr);
              TEST_ASSERT(numberExpr->isFinal() == *opt.expectExitResultFinal);
          }
 Line 285 
 end on
          .expectRealExitResult = 6.9
      });
+     // int array tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %foo[3]
+   %foo[0] := 21
+   exit(%foo[0])
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 21
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %foo[3] := ( 12, 23, 34 )
+   exit(%foo[0])
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 12
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %foo[3] := ( 12, 23, 34 )
+   exit(%foo[1])
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 23
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %foo[3] := ( 12, 23, 34 )
+   exit(%foo[2])
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 34
+     });
+     runScript({ // make sure array is entirely initialized with zeroes
+         .code = R"NKSP_CODE(
+ on init
+   declare $i
+   declare $result
+   declare %foo[100]
+   while ($i < 100)
+       $result := $result .or. %foo[$i]
+       inc($i)
+   end while
+   exit($result)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 0
+     });
+     // real array tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?foo[3]
+   ?foo[0] := 34.9
+   exit(?foo[0])
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 34.9
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?foo[3] := ( 0.3, 23.5, 900.1 )
+   exit(?foo[0])
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.3
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?foo[3] := ( 0.3, 23.5, 900.1 )
+   exit(?foo[1])
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 23.5
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?foo[3] := ( 0.3, 23.5, 900.1 )
+   exit(?foo[2])
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 900.1
+     });
+     runScript({ // make sure array is entirely initialized with zeroes
+         .code = R"NKSP_CODE(
+ on init
+   declare $i
+   declare ?foo[100]
+   while ($i < 100)
+       if (?foo[$i] # 0.0)
+         exit(-1) { test failed }
+       end if
+       inc($i)
+   end while
+   exit(0) { test succeeded }
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 0
+     });
      // std unit tests ...
      runScript({
-Line 1135 
 end on
+Line 1254 
 end on
          .expectExitResultFinal = false
      });
+     //TODO: the following are unary '+' operator tests which should be moved to their own function (lazy me).
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit(+54)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 54
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := +54
+   exit( $foo )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 54
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit(+0.45)
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.45
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~foo := +0.29
+   exit( ~foo )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.29
+     });
      #if !SILENT_TEST
      std::cout << std::endl;
      #endif
-Line 1936 
 end on
+Line 2095 
 end on
          .expectExitResultUnit = VM_SECOND
      });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~foo := 1.0  { neutral }
+   declare $bar := 7000ms
+   exit(~foo * real($bar))
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 7000.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+  runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1  { neutral }
+   declare $bar := 7000ms
+   exit(real($foo) * real($bar))
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 7000.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
      // 'final' ('!') operator tests ...
      runScript({
-Line 2193 
 end on
+Line 2378 
 end on
          .expectParseError = true // unit types are not matching
      });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1000000
+   declare $bar := 7000ms
+   exit(real($foo) / 1000000.0 * real($bar))
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 7000.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
      // 'final' ('!') operator tests ...
      runScript({
-Line 5254 
 end on
+Line 5452 
 end on
      #endif
  }
+ static void testIntVarDeclaration() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: int var declaration\n";
+     #endif
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $a
+   exit($a)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $a := 24
+   exit($a)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 24
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $a := 24
+   $a := 8
+   exit($a)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 8
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $a
+   declare $a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // variable re-declaration
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const $a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // const variable declaration without assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const $a := 24
+   exit($a)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 24
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const $a := 24
+   $a := 8
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // attempt to modify const variable
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const $a := 24
+   declare const $b := $a
+   exit($b)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 24
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $a := 24
+   declare const $b := $a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // const variable defined with non-const assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic $a
+   exit($a)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const polyphonic $a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic const $a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const polyphonic $a := 3
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic const $a := 3
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~a := 24
+   exit(~a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // real type declaration vs. int value assignment
+         .expectIntExitResult = 24
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a := 24
+   exit(%a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // int array type declaration vs. int scalar value assignment
+         .expectIntExitResult = 24
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const %a := 24
+   exit(%a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // int array type declaration vs. int scalar value assignment
+         .expectIntExitResult = 24
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a := 24
+   exit(?a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // real array type declaration vs. int scalar value assignment
+         .expectIntExitResult = 24
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ?a := 24
+   exit(?a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // real array type declaration vs. int scalar value assignment
+         .expectIntExitResult = 24
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare @a := 24
+   exit(@a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // string type declaration vs. int scalar value assignment
+         .expectIntExitResult = 24
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const @a := 24
+   exit(@a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // string type declaration vs. int scalar value assignment
+         .expectIntExitResult = 24
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $a := ( 0, 1, 2 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // int scalar type declaration vs. int array value assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const $a := ( 0, 1, 2 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // int scalar type declaration vs. int array value assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // missing type prefix character in variable name
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare a := 24
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // missing type prefix character in variable name
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const a := 24
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // missing type prefix character in variable name
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // missing type prefix character in variable name
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $a := max(8,24)
+   exit($a)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 24
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $a := abort($NI_CALLBACK_ID)
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // assigned expression does not result in a value
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const $a := abort($NI_CALLBACK_ID)
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // assigned expression does not result in a value
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testIntArrayVarDeclaration() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: int array var declaration\n";
+     #endif
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[3]
+   exit( %a[0] + %a[1] + %a[2] )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[0]
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true // unusable array size
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[-1]
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // illegal array size
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[3] := ( 1, 2, 3 )
+   exit( %a[0] + %a[1] + %a[2] )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = (1 + 2 + 3)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[] := ( 1, 2, 3 )
+   exit( %a[0] + %a[1] + %a[2] )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = (1 + 2 + 3)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[]
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true // unusable array size (zero)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const $sz := 3
+   declare %a[$sz] := ( 1, 2, 3 )
+   exit( %a[0] + %a[1] + %a[2] )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = (1 + 2 + 3)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const $sz := 3
+   declare const %a[$sz] := ( 1, 2, 3 )
+   exit( %a[0] + %a[1] + %a[2] )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = (1 + 2 + 3)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $sz := 3
+   declare %a[$sz] := ( 1, 2, 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // array size must be constant expression
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $sz := 3
+   declare const %a[$sz] := ( 1, 2, 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // array size must be constant expression
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ~sz := 3.0
+   declare const %a[~sz] := ( 1, 2, 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // array size must be integer type
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[3s] := ( 1, 2, 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // units not allowed for array size
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[3m] := ( 1, 2, 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // units not allowed for array size
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const %a[!3] := ( 1, 2, 3 )
+   exit( %a[0] + %a[1] + %a[2] )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = (1 + 2 + 3),
+         .expectParseWarning = true // 'final' operator is meaningless for array size
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[3] := ( 1, 2, 3 )
+   %a[0] := 4
+   %a[1] := 5
+   %a[2] := 6
+   exit( %a[0] + %a[1] + %a[2] )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = (4 + 5 + 6)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[3]
+   declare %a[3]
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // variable re-declaration
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const %a[3]
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // const variable declaration without assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const %a[3] := ( 1, 2, 3 )
+   exit( %a[0] + %a[1] + %a[2] )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = (1 + 2 + 3)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const %a[3] := ( 1, 2, 3, 4 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // incompatible array sizes
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const %a[3] := ( 1, 2, 3 )
+   %a[0] := 8
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // attempt to modify const variable
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const %a[3] := ( 1, 2, 3 )
+   declare const %b[3] := ( %a[0], %a[1], %a[2] )
+   exit( %b[0] + %b[1] + %b[2] )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = (1 + 2 + 3)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[3] := ( 1, 2, 3 )
+   declare const %b[3] := ( %a[0], %a[1], %a[2] )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // const array defined with non-const assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic %a[3]
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // polyphonic not allowed for array types
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic %a[3] := ( 1, 2, 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // polyphonic not allowed for array types
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const polyphonic %a[3]
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // polyphonic not allowed for array types
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const polyphonic %a[3] := ( 1, 2, 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // polyphonic not allowed for array types
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic const %a[3]
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // polyphonic not allowed for array types
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic const %a[3] := ( 1, 2, 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // polyphonic not allowed for array types
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[3] := ( 1, max(8,24), 3 )
+   exit( %a[0] + %a[1] + %a[2] )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = ( 1 + 24 + 3 )
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[3] := ( 1, abort($NI_CALLBACK_ID), 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // assigned expression does not result in a value
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const %a[3] := ( 1, abort($NI_CALLBACK_ID), 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // assigned expression does not result in a value
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[3] := ( 1.0, 2.0, 3.0 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // int array declaration vs. real array assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[3] := ( 1, 2, 3.0 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // 3rd element not an integer
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a[3] := ( "x", "y", "z" )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // int array declaration vs. string array assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare a[3] := ( 1, 2, 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // missing type prefix character in variable name
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare a[3]
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // missing type prefix character in variable name
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const %a[3] := ( 1, 2s, 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // unit types not allowed for arrays
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const %a[3] := ( 1, !2, 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // 'final' not allowed for arrays
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testRealVarDeclaration() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: real var declaration\n";
+     #endif
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~a
+   exit(~a)
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~a := 24.8
+   exit(~a)
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 24.8
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~a := 8.24
+   ~a := 24.8
+   exit(~a)
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 24.8
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~a
+   declare ~a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // variable re-declaration
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ~a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // const variable declaration without assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ~a := 8.24
+   exit(~a)
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 8.24
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ~a := 28.0
+   ~a := 8.0
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // attempt to modify const variable
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ~a := 24.8
+   declare const ~b := ~a
+   exit(~b)
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 24.8
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~a := 24.0
+   declare const ~b := ~a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // const variable defined with non-const assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic ~a
+   exit(~a)
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const polyphonic ~a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic const ~a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const polyphonic ~a := 3.0
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic const ~a := 3.0
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $a := 24.8
+   exit($a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // int type declaration vs. real value assignment
+         .expectRealExitResult = 24.8
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a := 24.8
+   exit(%a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // int array type declaration vs. real scalar value assignment
+         .expectRealExitResult = 24.8
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const %a := 24.8
+   exit(%a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // int array type declaration vs. real scalar value assignment
+         .expectRealExitResult = 24.8
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a := 24.8
+   exit(?a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // real array type declaration vs. real scalar value assignment
+         .expectRealExitResult = 24.8
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ?a := 24.8
+   exit(?a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // real array type declaration vs. real scalar value assignment
+         .expectRealExitResult = 24.8
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare @a := 24.8
+   exit(@a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // string type declaration vs. real scalar value assignment
+         .expectRealExitResult = 24.8
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const @a := 24.8
+   exit(@a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // string type declaration vs. real scalar value assignment
+         .expectRealExitResult = 24.8
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~a := ( 0, 1, 2 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // real scalar type declaration vs. int array value assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ~a := ( 0, 1, 2 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // real scalar type declaration vs. int array value assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare a := 24.8
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // missing type prefix character in variable name
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const a := 24.8
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // missing type prefix character in variable name
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~a := max(8.1,24.2)
+   exit(~a)
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 24.2
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~a := abort($NI_CALLBACK_ID)
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // assigned expression does not result in a value
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ~a := abort($NI_CALLBACK_ID)
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // assigned expression does not result in a value
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testRealArrayVarDeclaration() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: real array var declaration\n";
+     #endif
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[3]
+   exit( ?a[0] + ?a[1] + ?a[2] )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[0]
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true // unusable array size
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[-1]
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // illegal array size
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[3] := ( 1.1, 2.2, 3.3 )
+   exit( ?a[0] + ?a[1] + ?a[2] )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = (1.1 + 2.2 + 3.3)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[] := ( 1.1, 2.2, 3.3 )
+   exit( ?a[0] + ?a[1] + ?a[2] )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = (1.1 + 2.2 + 3.3)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[]
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true // unusable array size (zero)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const $sz := 3
+   declare ?a[$sz] := ( 1.1, 2.2, 3.3 )
+   exit( ?a[0] + ?a[1] + ?a[2] )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = (1.1 + 2.2 + 3.3)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const $sz := 3
+   declare const ?a[$sz] := ( 1.1, 2.2, 3.3 )
+   exit( ?a[0] + ?a[1] + ?a[2] )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = (1.1 + 2.2 + 3.3)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $sz := 3
+   declare ?a[$sz] := ( 1.1, 2.2, 3.3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // array size must be constant expression
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $sz := 3
+   declare const ?a[$sz] := ( 1.1, 2.2, 3.3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // array size must be constant expression
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ~sz := 3.0
+   declare const ?a[~sz] := ( 1.1, 2.2, 3.3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // array size must be integer type
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[3s] := ( 1.1, 2.2, 3.3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // units not allowed for array size
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[3m] := ( 1.1, 2.2, 3.3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // units not allowed for array size
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ?a[!3] := ( 1.1, 2.2, 3.3 )
+   exit( ?a[0] + ?a[1] + ?a[2] )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = (1.1 + 2.2 + 3.3),
+         .expectParseWarning = true // 'final' operator is meaningless for array size
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[3] := ( 1.0, 2.0, 3.0 )
+   ?a[0] := 4.5
+   ?a[1] := 5.5
+   ?a[2] := 6.5
+   exit( ?a[0] + ?a[1] + ?a[2] )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = (4.5 + 5.5 + 6.5)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[3]
+   declare ?a[3]
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // variable re-declaration
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ?a[3]
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // const variable declaration without assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ?a[3] := ( 1.1, 2.2, 3.3 )
+   exit( ?a[0] + ?a[1] + ?a[2] )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = (1.1 + 2.2 + 3.3)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ?a[3] := ( 1.1, 2.2, 3.3, 4.4 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // incompatible array sizes
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ?a[3] := ( 1.0, 2.0, 3.0 )
+   ?a[0] := 8.0
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // attempt to modify const variable
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ?a[3] := ( 1.1, 2.2, 3.3 )
+   declare const ?b[3] := ( ?a[0], ?a[1], ?a[2] )
+   exit( ?b[0] + ?b[1] + ?b[2] )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = (1.1 + 2.2 + 3.3)
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[3] := ( 1.1, 2.2, 3.3 )
+   declare const ?b[3] := ( ?a[0], ?a[1], ?a[2] )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // const array defined with non-const assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic ?a[3]
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // polyphonic not allowed for array types
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic ?a[3] := ( 1.0, 2.0, 3.0 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // polyphonic not allowed for array types
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const polyphonic ?a[3]
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // polyphonic not allowed for array types
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const polyphonic ?a[3] := ( 1.0, 2.0, 3.0 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // polyphonic not allowed for array types
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic const ?a[3]
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // polyphonic not allowed for array types
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic const ?a[3] := ( 1.0, 2.0, 3.0 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // polyphonic not allowed for array types
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[3] := ( 1.0, max(8.3,24.6), 3.0 )
+   exit( ?a[0] + ?a[1] + ?a[2] )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = ( 1.0 + 24.6 + 3.0 )
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[3] := ( 1.0, abort($NI_CALLBACK_ID), 3.0 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // assigned expression does not result in a value
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ?a[3] := ( 1.0, abort($NI_CALLBACK_ID), 3.0 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // assigned expression does not result in a value
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[3] := ( 1, 2, 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // real array declaration vs. int array assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[3] := ( 1.0, 2.0, 3 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // 3rd element not a real value
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ?a[3] := ( "x", "y", "z" )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // real array declaration vs. string array assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare a[3] := ( 1.0, 2.0, 3.0 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // missing type prefix character in variable name
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ?a[3] := ( 1.0, 2.0s, 3.0 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // unit types not allowed for arrays
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ?a[3] := ( 1.0, !2.0, 3.0 )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // 'final' not allowed for arrays
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testStringVarDeclaration() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: string var declaration\n";
+     #endif
+ runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare @a
+   exit(@a)
+ end on
+ )NKSP_CODE",
+         .expectStringExitResult = ""
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare @a := "foo"
+   exit(@a)
+ end on
+ )NKSP_CODE",
+         .expectStringExitResult = "foo"
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare @a := "foo"
+   @a := "bar"
+   exit(@a)
+ end on
+ )NKSP_CODE",
+         .expectStringExitResult = "bar"
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare @a
+   declare @a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // variable re-declaration
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const @a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // const variable declaration without assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const @a := "foo"
+   exit(@a)
+ end on
+ )NKSP_CODE",
+         .expectStringExitResult = "foo"
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const @a := "foo"
+   @a := "bar"
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // attempt to modify const variable
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const @a := "foo"
+   declare const @b := @a
+   exit(@b)
+ end on
+ )NKSP_CODE",
+         .expectStringExitResult = "foo"
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare @a := "foo"
+   declare const @b := @a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // const variable defined with non-const assignment
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic @a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // 'polyphonic' not allowed for string type
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const polyphonic @a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // 'polyphonic' not allowed for string type
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic const @a
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // 'polyphonic' not allowed for string type
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic @a = "foo"
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // 'polyphonic' not allowed for string type
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare polyphonic const @a = "foo"
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // 'polyphonic' not allowed for string type
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const polyphonic @a = "foo"
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // 'polyphonic' not allowed for string type
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $a := "foo"
+   exit($a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // int type declaration vs. string assignment
+         .expectStringExitResult = "foo"
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~a := "foo"
+   exit(~a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // real type declaration vs. string assignment
+         .expectStringExitResult = "foo"
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare %a := "foo"
+   exit(%a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // int array type declaration vs. string assignment
+         .expectStringExitResult = "foo"
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const $a := "foo"
+   exit($a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // int type declaration vs. string assignment
+         .expectStringExitResult = "foo"
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const ~a := "foo"
+   exit(~a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // real type declaration vs. string assignment
+         .expectStringExitResult = "foo"
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const %a := "foo"
+   exit(%a)
+ end on
+ )NKSP_CODE",
+         .expectParseWarning = true, // int array type declaration vs. string assignment
+         .expectStringExitResult = "foo"
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare a := "foo"
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // missing type prefix character in variable name
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const a := "foo"
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // missing type prefix character in variable name
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare @a := abort($NI_CALLBACK_ID)
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // assigned expression does not result in a value
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare const @a := abort($NI_CALLBACK_ID)
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // assigned expression does not result in a value
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
  static void testBuiltInMinFunction() {
      #if !SILENT_TEST
      std::cout << "UNIT TEST: built-in min() function\n";
-Line 6982 
 end on
+Line 8772 
 end on
      #endif
  }
+ static void testBuiltInMsbFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in msb() function\n";
+     #endif
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( msb(0) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( msb(127) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( msb(128) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 1
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( msb(16255) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 126
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( msb(16256) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 127
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( msb(16383) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 127
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInLsbFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in lsb() function\n";
+     #endif
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( lsb(0) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( lsb(1) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 1
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( lsb(126) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 126
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( lsb(127) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 127
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( lsb(128) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( lsb(16255) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 127
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( lsb(16256) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 0
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
  static void testBuiltInIntToRealFunction() {
      #if !SILENT_TEST
      std::cout << "UNIT TEST: built-in int_to_real() function\n";
-Line 7031 
 end on
+Line 8958 
 end on
          .expectExitResultUnit = VM_BEL
      });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 7000ms
+   exit( int_to_real($foo) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 7000.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 7000ms
+   declare @s := "" & int_to_real($foo)
+   exit( @s )
+ end on
+ )NKSP_CODE",
+         .expectStringExitResult = "7000ms",
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 700ms
+   exit( int_to_real($foo) / 7.0 )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 100.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 700ms
+   exit( int_to_real($foo) / 7.0 & "" )
+ end on
+ )NKSP_CODE",
+         .expectStringExitResult = "100ms"
+     });
      // 'final' ('!') operator tests ...
      runScript({
-Line 7109 
 end on
+Line 9081 
 end on
          .expectExitResultUnit = VM_BEL
      });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 7000ms
+   exit( real($foo) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 7000.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 7000ms
+   declare @s := "" & real($foo)
+   exit( @s )
+ end on
+ )NKSP_CODE",
+         .expectStringExitResult = "7000ms",
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 700ms
+   exit( real($foo) / 7.0 )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 100.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 700ms
+   exit( real($foo) / 7.0 & "" )
+ end on
+ )NKSP_CODE",
+         .expectStringExitResult = "100ms"
+     });
      // 'final' ('!') operator tests ...
      runScript({
-Line 7176 
 end on
+Line 9193 
 end on
          .expectExitResultUnit = VM_BEL
      });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~foo := 9000.0us
+   exit( real_to_int(~foo) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 9000.0,
+         .expectExitResultUnitPrefix = { VM_MICRO },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~foo := 9000.0us
+   declare @s := "" & real_to_int(~foo)
+   exit( @s )
+ end on
+ )NKSP_CODE",
+         .expectStringExitResult = "9000us",
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~foo := 700.0ms
+   exit( real_to_int(~foo) / 7 )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 100,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~foo := 700.0ms
+   exit( real_to_int(~foo) / 7 & "" )
+ end on
+ )NKSP_CODE",
+         .expectStringExitResult = "100ms"
+     });
      // 'final' ('!') operator tests ...
      runScript({
-Line 7243 
 end on
+Line 9305 
 end on
          .expectExitResultUnit = VM_BEL
      });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~foo := 9000.0us
+   exit( int(~foo) )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 9000.0,
+         .expectExitResultUnitPrefix = { VM_MICRO },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~foo := 9000.0us
+   declare @s := "" & int(~foo)
+   exit( @s )
+ end on
+ )NKSP_CODE",
+         .expectStringExitResult = "9000us",
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~foo := 700.0ms
+   exit( int(~foo) / 7 )
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = 100,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare ~foo := 700.0ms
+   exit( int(~foo) / 7 & "" )
+ end on
+ )NKSP_CODE",
+         .expectStringExitResult = "100ms"
+     });
      // 'final' ('!') operator tests ...
      runScript({
-Line 7778 
 end on
+Line 9885 
 end on
      #endif
  }
+ static void testBuiltInRoundFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in round() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( round($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( round(99.4) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 99.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( round(99.5) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 100.0
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( round(2.4ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 2.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( round(2.6kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 3.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( round(123.8) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 124.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( round(!123.8) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 124.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInCeilFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in ceil() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( ceil($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( ceil(99.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 99.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( ceil(99.1) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 100.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( ceil(99.9) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 100.0
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( ceil(2.4ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 3.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( ceil(2.6kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 3.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( ceil(9.4ms / 2.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 5.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( ceil( ceil(8.4us) / 2.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 5.0,
+         .expectExitResultUnitPrefix = { VM_MICRO },
+         .expectExitResultUnit = VM_SECOND
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( ceil(123.1) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 124.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( ceil(!123.8) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 124.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInFloorFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in floor() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( floor($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( floor(99.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 99.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( floor(99.1) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 99.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( floor(99.9) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 99.0
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( floor(2.4ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 2.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( floor(2.6kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 2.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( floor(4.4ms / 2.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 2.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( floor( floor(8.4us) / 4.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 2.0,
+         .expectExitResultUnitPrefix = { VM_MICRO },
+         .expectExitResultUnit = VM_SECOND
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( floor(123.1) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 123.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( floor(!123.8) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 123.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInSqrtFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in sqrt() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( sqrt($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( sqrt(36.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 6.0
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( sqrt(100.0ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 10.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( sqrt(5.76kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 2.4,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( sqrt(25.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 5.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( sqrt(!25.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 5.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInLogFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in log() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( log($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log(1.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log(~NI_MATH_E) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log(~NI_MATH_E * 1.0ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log(~NI_MATH_E * 1.0kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log(~NI_MATH_E * 1.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log(!(~NI_MATH_E * 1.0)) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInLog2Function() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in log2() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( log2($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log2(1.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log2(32.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 5.0
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log2(32.0ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 5.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log2(32.0kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 5.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log2(32.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 5.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log2(!32.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 5.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInLog10Function() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in log10() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( log10($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log10(1000.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 3.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log10(1000.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 3.0
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log10(1000.0ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 3.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log10(1000.0kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 3.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log10(1000.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 3.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( log10(!1000.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 3.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInExpFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in exp() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( exp($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( exp(0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( exp(1.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = M_E
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( exp(0.0ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( exp(0.0kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( exp(0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( exp(!0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInPowFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in pow() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( pow($foo,$foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( pow(1.0) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // because pow() requires exactly 2 arguments
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( pow(3.0,4.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 81.0
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( pow(3.0ms,4.0ms) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // because units are prohibited for 2nd argument
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( pow(3.0,4.0ms) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // because units are prohibited for 2nd argument
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( pow(3.0ms,4.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 81.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( pow(3.0kHz,4.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 81.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( pow(3.0,4.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 81.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( pow(!3.0,4.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 81.0,
+         .expectExitResultFinal = true
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( pow(3.0,!4.0) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // because 'final' is meaningless for 2nd argument
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInSinFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in sin() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( sin($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( sin(0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( sin(0.5 * ~NI_MATH_PI) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( sin(~NI_MATH_PI) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( sin(1.5 * ~NI_MATH_PI) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = -1.0
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( sin(0.0ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( sin(0.0kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( sin(0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( sin(!0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInCosFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in cos() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( cos($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( cos(0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( cos(0.5 * ~NI_MATH_PI) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( cos(~NI_MATH_PI) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = -1.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( cos(1.5 * ~NI_MATH_PI) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( cos(0.0ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( cos(0.0kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( cos(0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( cos(!0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInTanFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in tan() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( tan($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( tan(0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( tan(0.25 * ~NI_MATH_PI) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 1.0
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( tan(0.0ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( tan(0.0kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( tan(0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( tan(!0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInAsinFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in asin() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( asin($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( asin(0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( asin(1.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.5 * M_PI
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( asin(-1.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = -0.5 * M_PI
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( asin(0.0ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( asin(0.0kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( asin(0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( asin(!0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInAcosFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in acos() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( acos($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( acos(1.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( acos(0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.5 * M_PI
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( acos(-1.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = M_PI
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( acos(1.0ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( acos(1.0kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( acos(1.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( acos(!1.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
+ static void testBuiltInAtanFunction() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in atan() function\n";
+     #endif
+     // integer tests ...
+     // (ATM not allowed for this function)
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   declare $foo := 1
+   exit( atan($foo) )
+ end on
+ )NKSP_CODE",
+         .expectParseError = true // integer not allowed for this function ATM
+     });
+     // real number tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( atan(0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( atan(1.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.25 * M_PI
+     });
+     // std unit tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( atan(0.0ms) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultUnitPrefix = { VM_MILLI },
+         .expectExitResultUnit = VM_SECOND
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( atan(0.0kHz) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultUnitPrefix = { VM_KILO },
+         .expectExitResultUnit = VM_HERTZ
+     });
+     // 'final' ('!') operator tests ...
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( atan(0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultFinal = false
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit( atan(!0.0) )
+ end on
+ )NKSP_CODE",
+         .expectRealExitResult = 0.0,
+         .expectExitResultFinal = true
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
  static void testBuiltInNumElementsFunction() {
      #if !SILENT_TEST
      std::cout << "UNIT TEST: built-in num_elements() function\n";
-Line 8034 
 end on
+Line 11610 
 end on
      #endif
  }
+ static void testBuiltInVars() {
+     #if !SILENT_TEST
+     std::cout << "UNIT TEST: built-in variables\n";
+     #endif
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit($NKSP_PERF_TIMER)
+ end on
+ )NKSP_CODE",
+         .expectExitResultIsInt = true,
+         .expectExitResultUnitPrefix = { VM_NO_PREFIX },
+         .expectExitResultUnit = VM_NO_UNIT
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit($NKSP_REAL_TIMER)
+ end on
+ )NKSP_CODE",
+         .expectExitResultIsInt = true,
+         .expectExitResultUnitPrefix = { VM_NO_PREFIX },
+         .expectExitResultUnit = VM_NO_UNIT
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit($KSP_TIMER)
+ end on
+ )NKSP_CODE",
+         .expectExitResultIsInt = true,
+         .expectExitResultUnitPrefix = { VM_NO_PREFIX },
+         .expectExitResultUnit = VM_NO_UNIT
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit(~NI_MATH_PI)
+ end on
+ )NKSP_CODE",
+         .expectExitResultIsReal = true,
+         .expectExitResultUnitPrefix = { VM_NO_PREFIX },
+         .expectExitResultUnit = VM_NO_UNIT
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit(~NI_MATH_E)
+ end on
+ )NKSP_CODE",
+         .expectExitResultIsReal = true,
+         .expectExitResultUnitPrefix = { VM_NO_PREFIX },
+         .expectExitResultUnit = VM_NO_UNIT
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit($NI_CB_TYPE_INIT)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = VM_EVENT_HANDLER_INIT,
+         .expectExitResultUnitPrefix = { VM_NO_PREFIX },
+         .expectExitResultUnit = VM_NO_UNIT
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit($NI_CB_TYPE_NOTE)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = VM_EVENT_HANDLER_NOTE,
+         .expectExitResultUnitPrefix = { VM_NO_PREFIX },
+         .expectExitResultUnit = VM_NO_UNIT
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit($NI_CB_TYPE_RELEASE)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = VM_EVENT_HANDLER_RELEASE,
+         .expectExitResultUnitPrefix = { VM_NO_PREFIX },
+         .expectExitResultUnit = VM_NO_UNIT
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit($NI_CB_TYPE_CONTROLLER)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = VM_EVENT_HANDLER_CONTROLLER,
+         .expectExitResultUnitPrefix = { VM_NO_PREFIX },
+         .expectExitResultUnit = VM_NO_UNIT
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit($NI_CB_TYPE_RPN)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = VM_EVENT_HANDLER_RPN,
+         .expectExitResultUnitPrefix = { VM_NO_PREFIX },
+         .expectExitResultUnit = VM_NO_UNIT
+     });
+     runScript({
+         .code = R"NKSP_CODE(
+ on init
+   exit($NI_CB_TYPE_NRPN)
+ end on
+ )NKSP_CODE",
+         .expectIntExitResult = VM_EVENT_HANDLER_NRPN,
+         .expectExitResultUnitPrefix = { VM_NO_PREFIX },
+         .expectExitResultUnit = VM_NO_UNIT
+     });
+     #if !SILENT_TEST
+     std::cout << std::endl;
+     #endif
+ }
  #if !NO_MAIN
  int main() {
-Line 8058 
 int main() {
+Line 11765 
 int main() {
      testBitwiseOrOperator();
      testBitwiseNotOperator();
      testPrecedenceOfOperators();
+     testIntVarDeclaration();
+     testIntArrayVarDeclaration();
+     testRealVarDeclaration();
+     testRealArrayVarDeclaration();
+     testStringVarDeclaration();
      testBuiltInMinFunction();
      testBuiltInMaxFunction();
      testBuiltInAbsFunction();
-Line 8067 
 int main() {
+Line 11779 
 int main() {
      testBuiltInRandomFunction();
      testBuiltInShiftLeftFunction();
      testBuiltInShiftRightFunction();
+     testBuiltInMsbFunction();
+     testBuiltInLsbFunction();
      testBuiltInIntToRealFunction();
      testBuiltInRealFunction();
      testBuiltInRealToIntFunction();
      testBuiltInIntFunction();
+     testBuiltInRoundFunction();
+     testBuiltInCeilFunction();
+     testBuiltInFloorFunction();
+     testBuiltInSqrtFunction();
+     testBuiltInLogFunction();
+     testBuiltInLog2Function();
+     testBuiltInLog10Function();
+     testBuiltInExpFunction();
+     testBuiltInPowFunction();
+     testBuiltInSinFunction();
+     testBuiltInCosFunction();
+     testBuiltInTanFunction();
+     testBuiltInAsinFunction();
+     testBuiltInAcosFunction();
+     testBuiltInAtanFunction();
      testBuiltInArrayEqualFunction();
      testBuiltInSortFunction();
      testBuiltInNumElementsFunction();
      testBuiltInSearchFunction();
      testIfStatement();
      testWhileStatement();
+     testBuiltInVars();
      std::cout << "\nAll tests passed successfully. :-)\n";
      return 0;
  }

 Legend:



Removed from v.3581
 


changed lines


 
Added in v.3790
 Legend:



Removed from v.3581
 


changed lines


 
Added in v.3790
-Removed from v.3581
+Added in v.3790

	ViewVC Help
Powered by ViewVC