scriptvm/tests/NKSPCoreLangTest.cpp

/*
 * Copyright (c) 2019 Christian Schoenebeck
 *
 * http://www.linuxsampler.org
 *
 * This file is part of LinuxSampler and released under the same terms.
 * See README file for details.
 */

// This file contains automated test cases against the NKSP real-time
// instrument script engine.

#include "../../common/global.h"
#include "../../common/optional.h"
#include "../../common/RTMath.h"
#include "../ScriptVM.h"
#include "../common.h"
#include <sstream>
#include <stdlib.h>
#include <time.h>
#include <assert.h>
#include <functional>

#ifndef TEST_ASSERT
# define TEST_ASSERT assert
#endif

using namespace LinuxSampler;
using namespace std;

struct RunScriptOpt {
    String code;
    bool expectParseError;
    bool expectParseWarning;
    bool expectRuntimeError;
    bool expectNoExitResult;
    bool expectExitResultIsInt;
    bool expectExitResultIsReal;
    bool prohibitExitFunctionArguments;
    optional<vmint> expectIntExitResult;
    optional<bool> expectBoolExitResult;
    optional<vmfloat> expectRealExitResult;
    optional<String> expectStringExitResult;
    vector<MetricPrefix_t> expectExitResultUnitPrefix;
    optional<StdUnit_t> expectExitResultUnit;
    optional<bool> expectExitResultFinal;
};

static void runScript(const RunScriptOpt& opt) {
    ScriptVM vm;
    vm.setAutoSuspendEnabled(false);
    if (!opt.prohibitExitFunctionArguments)
        vm.setExitResultEnabled(true);
    unique_ptr<VMParserContext> parserCtx(
        vm.loadScript(opt.code)
    );
    vector<ParserIssue> errors = parserCtx->errors();
    vector<ParserIssue> warnings = parserCtx->warnings();
    if (opt.expectParseError) {
        TEST_ASSERT(!errors.empty());
        return;
    } else {
        for (ParserIssue& err : errors) {
            err.dump();
        }
        TEST_ASSERT(errors.empty());
    }
    if (opt.expectParseWarning) {
        TEST_ASSERT(!warnings.empty());
    } else {
        for (ParserIssue& wrn : warnings) {
            wrn.dump();
        }
    }
    TEST_ASSERT(parserCtx->eventHandler(0));
    unique_ptr<VMExecContext> execCtx(
        vm.createExecContext(&*parserCtx)
    );
    for (int i = 0; parserCtx->eventHandler(i); ++i) {
        VMEventHandler* handler = parserCtx->eventHandler(i);
        VMExecStatus_t result = vm.exec(&*parserCtx, &*execCtx, handler);
        if (opt.expectRuntimeError) {
            TEST_ASSERT(result & VM_EXEC_ERROR);
        } else {
            TEST_ASSERT(!(result & VM_EXEC_ERROR));
        }
        if (opt.expectNoExitResult) {
            VMExpr* resExpr = execCtx->exitResult();
            TEST_ASSERT(!resExpr);
        }
        if (opt.expectExitResultIsInt) {
            VMExpr* resExpr = execCtx->exitResult();
            TEST_ASSERT(resExpr);
            TEST_ASSERT(resExpr->exprType() == INT_EXPR);
        }
        if (opt.expectExitResultIsReal) {
            VMExpr* resExpr = execCtx->exitResult();
            TEST_ASSERT(resExpr);
            TEST_ASSERT(resExpr->exprType() == REAL_EXPR);
        }
        if (opt.expectIntExitResult) {
            VMExpr* resExpr = execCtx->exitResult();
            TEST_ASSERT(resExpr);
            TEST_ASSERT(resExpr->exprType() == INT_EXPR);
            TEST_ASSERT(resExpr->asInt()->evalInt() == *opt.expectIntExitResult);
        }
        if (opt.expectRealExitResult) {
            VMExpr* resExpr = execCtx->exitResult();
            TEST_ASSERT(resExpr);
            TEST_ASSERT(resExpr->exprType() == REAL_EXPR);
            if (sizeof(vmfloat) == sizeof(float)) {
                TEST_ASSERT(RTMath::fEqual32(resExpr->asReal()->evalReal(), *opt.expectRealExitResult));
            } else {
                TEST_ASSERT(RTMath::fEqual64(resExpr->asReal()->evalReal(), *opt.expectRealExitResult));
            }
        }
        if (opt.expectBoolExitResult) {
            VMExpr* resExpr = execCtx->exitResult();
            TEST_ASSERT(resExpr);
            TEST_ASSERT(resExpr->exprType() == INT_EXPR);
            TEST_ASSERT(bool(resExpr->asInt()->evalInt()) == *opt.expectBoolExitResult);
        }
        if (opt.expectStringExitResult) {
            VMExpr* resExpr = execCtx->exitResult();
            TEST_ASSERT(resExpr);
            TEST_ASSERT(resExpr->exprType() == STRING_EXPR);
            TEST_ASSERT(resExpr->asString()->evalStr() == *opt.expectStringExitResult);
        }
        if (opt.expectExitResultUnit) {
            VMExpr* resExpr = execCtx->exitResult();
            TEST_ASSERT(resExpr);
            VMNumberExpr* numberExpr = resExpr->asNumber();
            TEST_ASSERT(numberExpr);
            TEST_ASSERT(numberExpr->unitType() == *opt.expectExitResultUnit);
        }
        if (!opt.expectExitResultUnitPrefix.empty()) {
            VMExpr* resExpr = execCtx->exitResult();
            TEST_ASSERT(resExpr);
            VMNumberExpr* numberExpr = resExpr->asNumber();
            TEST_ASSERT(numberExpr);
            auto prefixes = opt.expectExitResultUnitPrefix;
            if (*prefixes.rbegin() != VM_NO_PREFIX)
                prefixes.push_back(VM_NO_PREFIX); // VM_NO_PREFIX termination required by unitFactr() call
            vmfloat expectedFactor = VMUnit::unitFactor(&prefixes[0]);
            vmfloat actualFactor = numberExpr->unitFactor();
            if (sizeof(vmfloat) == sizeof(float)) {
                TEST_ASSERT(RTMath::fEqual32(expectedFactor, actualFactor));
            } else {
                TEST_ASSERT(RTMath::fEqual64(expectedFactor, actualFactor));
            }
        }
        if (opt.expectExitResultFinal) {
            VMExpr* resExpr = execCtx->exitResult();
            TEST_ASSERT(resExpr);
            VMNumberExpr* numberExpr = resExpr->asNumber();
            TEST_ASSERT(numberExpr);
            TEST_ASSERT(numberExpr->isFinal() == *opt.expectExitResultFinal);
        }
    }
}

static void testBuiltInExitFunction() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: built-in exit() function\n";
    #endif

    runScript({
        .code = R"NKSP_CODE(
on init
end on
)NKSP_CODE",
        .expectNoExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit
end on
)NKSP_CODE",
        .expectNoExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit()
end on
)NKSP_CODE",
        .expectNoExitResult = true
    });

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42)
end on
)NKSP_CODE",
        .expectIntExitResult = 42
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $foo := 1
  if ($foo)
    exit(21)
  end if
end on
)NKSP_CODE",
        .expectIntExitResult = 21
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $foo := 0
  if ($foo)
    exit(21)
  end if
  exit(99)
end on
)NKSP_CODE",
        .expectIntExitResult = 99
    });

    // string tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit("fourtytwo!")
end on
)NKSP_CODE",
        .expectStringExitResult = "fourtytwo!"
    });

    // in production environment we prohibit the built-in exit() function to
    // accept any arguments
    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42)
end on
)NKSP_CODE",
        .expectParseError = true, // see comment above why
        .prohibitExitFunctionArguments = true // simulate production environment
    });

    // real number tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.14)
end on
)NKSP_CODE",
        .expectRealExitResult = 3.14
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $foo := 1
  if ($foo)
    exit(3.14)
  end if
end on
)NKSP_CODE",
        .expectRealExitResult = 3.14
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $foo := 0
  if ($foo)
    exit(3.14)
  end if
  exit(6.9)
end on
)NKSP_CODE",
        .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({
        .code = R"NKSP_CODE(
on init
  exit(42s)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42Hz)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnit = VM_HERTZ
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42B)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42us)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_MICRO },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42ms)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42cs)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_CENTI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42ds)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_DECI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42das)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_DECA },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42hs)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_HECTO },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42ks)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_KILO },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42s)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_NO_PREFIX },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42uHz)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_MICRO },
        .expectExitResultUnit = VM_HERTZ
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42mHz)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_HERTZ
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42cHz)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_CENTI },
        .expectExitResultUnit = VM_HERTZ
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42dHz)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_DECI },
        .expectExitResultUnit = VM_HERTZ
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42daHz)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_DECA },
        .expectExitResultUnit = VM_HERTZ
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42hHz)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_HECTO },
        .expectExitResultUnit = VM_HERTZ
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42kHz)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_KILO },
        .expectExitResultUnit = VM_HERTZ
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42Hz)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_NO_PREFIX },
        .expectExitResultUnit = VM_HERTZ
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42uB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_MICRO },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42mB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42cB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_CENTI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42dB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42daB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_DECA },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42hB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_HECTO },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42kB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_KILO },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42B)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_NO_PREFIX },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42udB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_MICRO, VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42mdB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42cdB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_CENTI, VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42ddB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_DECI, VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42dadB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_DECA, VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42hdB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_HECTO, VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42kdB)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_KILO, VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $foo := 42mdB
  exit($foo)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.14s)
end on
)NKSP_CODE",
        .expectRealExitResult = 3.14,
        .expectExitResultUnitPrefix = { VM_NO_PREFIX },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.14us)
end on
)NKSP_CODE",
        .expectRealExitResult = 3.14,
        .expectExitResultUnitPrefix = { VM_MICRO },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.14ms)
end on
)NKSP_CODE",
        .expectRealExitResult = 3.14,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-0.1B)
end on
)NKSP_CODE",
        .expectRealExitResult = -0.1,
        .expectExitResultUnitPrefix = { VM_NO_PREFIX },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-0.1dB)
end on
)NKSP_CODE",
        .expectRealExitResult = -0.1,
        .expectExitResultUnitPrefix = { VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-0.1mdB)
end on
)NKSP_CODE",
        .expectRealExitResult = -0.1,
        .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~foo := -0.1mdB
  exit(~foo)
end on
)NKSP_CODE",
        .expectRealExitResult = -0.1,
        .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~foo := 0.0dB
  ~foo := -0.1mdB
  exit(~foo)
end on
)NKSP_CODE",
        .expectRealExitResult = -0.1,
        .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~foo := 0.0dB
  ~foo := -0.1Hz
  exit(~foo)
end on
)NKSP_CODE",
        .expectParseError = true // assigning different unit type to a variable is not allowed
    });

    // 'final' ('!') operator tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!42)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultFinal = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $foo := !42
  exit($foo)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $foo := 42
  exit($foo)
end on
)NKSP_CODE",
        .expectIntExitResult = 42,
        .expectExitResultFinal = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~foo := !3.14
  exit(~foo)
end on
)NKSP_CODE",
        .expectRealExitResult = 3.14,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~foo := 3.14
  exit(~foo)
end on
)NKSP_CODE",
        .expectRealExitResult = 3.14,
        .expectExitResultFinal = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~foo := !3.14mdB
  exit(~foo)
end on
)NKSP_CODE",
        .expectRealExitResult = 3.14,
        .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
        .expectExitResultUnit = VM_BEL,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~foo := !0.0mdB
  ~foo := !3.14mdB
  exit(~foo)
end on
)NKSP_CODE",
        .expectRealExitResult = 3.14,
        .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
        .expectExitResultUnit = VM_BEL,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~foo := !0.0mdB
  ~foo := 3.14mdB
  exit(~foo)
end on
)NKSP_CODE",
        .expectParseError = true // assigning non-final to a final variable not allowed
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~foo := 0.0mdB
  ~foo := !3.14mdB
  exit(~foo)
end on
)NKSP_CODE",
        .expectParseError = true // assigning final to a non-final variable not allowed
    });

    #if !SILENT_TEST
    std::cout << std::endl;
    #endif
}

static void testStringConcatOperator() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: string concatenation (&) operator\n";
    #endif

    // strings only tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  declare @s := "foo" & " bar"
  exit(@s)
end on
)NKSP_CODE",
        .expectStringExitResult = "foo bar"
    });

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  declare @s := "foo" & " bar" & " " & 123
  exit(@s)
end on
)NKSP_CODE",
        .expectStringExitResult = "foo bar 123"
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $i := 123
  declare @s := "foo" & " bar" & " " & $i
  exit(@s)
end on
)NKSP_CODE",
        .expectStringExitResult = "foo bar 123"
    });

    // real number tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  declare @s := "foo" & " bar" & " " & 1.23
  exit(@s)
end on
)NKSP_CODE",
        .expectStringExitResult = "foo bar 1.23"
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~r := 3.14
  declare @s := "foo" & " bar" & " " & ~r
  exit(@s)
end on
)NKSP_CODE",
        .expectStringExitResult = "foo bar 3.14"
    });

    // std unit tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $i := 500Hz
  declare @s := "foo" & " bar" & " " & $i
  exit(@s)
end on
)NKSP_CODE",
        .expectStringExitResult = "foo bar 500Hz"
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~r := 3.14s
  declare @s := "foo" & " bar" & " " & ~r
  exit(@s)
end on
)NKSP_CODE",
        .expectStringExitResult = "foo bar 3.14s"
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~r := -22.3mdB
  declare @s := "foo" & " bar" & " " & ~r
  exit(@s)
end on
)NKSP_CODE",
        .expectStringExitResult = "foo bar -22.3mdB"
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $i := 20us
  declare @s := "foo" & " bar" & " " & $i
  exit(@s)
end on
)NKSP_CODE",
        .expectStringExitResult = "foo bar 20us"
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $i := 20kHz
  declare @s := "foo" & " bar" & " " & $i
  exit(@s)
end on
)NKSP_CODE",
        .expectStringExitResult = "foo bar 20kHz"
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $i := -6dB
  declare @s := "foo" & " bar" & " " & $i
  exit(@s)
end on
)NKSP_CODE",
        .expectStringExitResult = "foo bar -6dB"
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $i := 1us * 1d
  declare @s := "foo" & " bar" & " " & $i
  exit(@s)
end on
)NKSP_CODE",
        .expectStringExitResult = "foo bar 1*10^-7s"
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~r := 12.4mc
  declare @s := "foo" & " bar" & " " & ~r
  exit(@s)
end on
)NKSP_CODE",
        .expectStringExitResult = "foo bar 12.4mc"
    });

    #if !SILENT_TEST
    std::cout << std::endl;
    #endif
}

static void testNegOperator() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: negate (-) operator\n";
    #endif

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-87)
end on
)NKSP_CODE",
        .expectIntExitResult = -87
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $foo := -87
  exit(-$foo)
end on
)NKSP_CODE",
        .expectIntExitResult = 87
    });

    // real number tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-99.3)
end on
)NKSP_CODE",
        .expectRealExitResult = -99.3
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~foo := -99.3
  exit(-~foo)
end on
)NKSP_CODE",
        .expectRealExitResult = 99.3
    });

    // std unit tests

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $foo := -87mdB
  exit(-$foo)
end on
)NKSP_CODE",
        .expectIntExitResult = 87,
        .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
        .expectExitResultUnit = VM_BEL
    });

    // 'final' ('!') operator tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $foo := !-87
  exit(-$foo)
end on
)NKSP_CODE",
        .expectIntExitResult = 87,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $foo := -87
  exit(-$foo)
end on
)NKSP_CODE",
        .expectIntExitResult = 87,
        .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
}

static void testPlusOperator() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: plus (+) operator\n";
    #endif

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4 + 3)
end on
)NKSP_CODE",
        .expectIntExitResult = 7
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42 + 145)
end on
)NKSP_CODE",
        .expectIntExitResult = 187
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4 + 2)
end on
)NKSP_CODE",
        .expectIntExitResult = -2
    });

    // real number tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4.0 + 3.0)
end on
)NKSP_CODE",
        .expectRealExitResult = 7.0
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42.3 + 145.2)
end on
)NKSP_CODE",
        .expectRealExitResult = 187.5
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4.0 + 2.2)
end on
)NKSP_CODE",
        .expectRealExitResult = -1.8
    });

    // std unit tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42ms + 145ms)
end on
)NKSP_CODE",
        .expectIntExitResult = 187,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s + 145ms)
end on
)NKSP_CODE",
        .expectIntExitResult = 1145,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42ms + 145)
end on
)NKSP_CODE",
        .expectParseError = true // units must match for + operator
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42 + 145ms)
end on
)NKSP_CODE",
        .expectParseError = true // units must match for + operator
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42Hz + 145s)
end on
)NKSP_CODE",
        .expectParseError = true // units must match for + operator
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42.1ms + 145.3ms)
end on
)NKSP_CODE",
        .expectRealExitResult = 187.4,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.1s + 145.0ms)
end on
)NKSP_CODE",
        .expectRealExitResult = 1245.0,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42.1ms + 145.3)
end on
)NKSP_CODE",
        .expectParseError = true // units must match for + operator
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42.0 + 145.0ms)
end on
)NKSP_CODE",
        .expectParseError = true // units must match for + operator
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(42.0Hz + 145.0s)
end on
)NKSP_CODE",
        .expectParseError = true // units must match for + operator
    });

    // 'final' ('!') operator tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!4 + !3)
end on
)NKSP_CODE",
        .expectIntExitResult = 7,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4 + 3)
end on
)NKSP_CODE",
        .expectIntExitResult = 7,
        .expectExitResultFinal = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!4.1 + !3.3)
end on
)NKSP_CODE",
        .expectRealExitResult = 7.4,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4.1 + 3.3)
end on
)NKSP_CODE",
        .expectRealExitResult = 7.4,
        .expectExitResultFinal = false
    });

    #if !SILENT_TEST
    std::cout << std::endl;
    #endif
}

static void testMinusOperator() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: minus (-) operator\n";
    #endif

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4 - 3)
end on
)NKSP_CODE",
        .expectIntExitResult = 1
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(139 - 74)
end on
)NKSP_CODE",
        .expectIntExitResult = 65
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 - 9)
end on
)NKSP_CODE",
        .expectIntExitResult = -6
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-3 - 18)
end on
)NKSP_CODE",
        .expectIntExitResult = -21
    });

    // real number tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4.0 - 0.2)
end on
)NKSP_CODE",
        .expectRealExitResult = 3.8
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.1 - 9.65)
end on
)NKSP_CODE",
        .expectRealExitResult = -6.55
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-3.0 - 18.1)
end on
)NKSP_CODE",
        .expectRealExitResult = -21.1
    });

    // std unit tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1000ms - 145ms)
end on
)NKSP_CODE",
        .expectIntExitResult = 855,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s - 145ms)
end on
)NKSP_CODE",
        .expectIntExitResult = 855,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s - 145)
end on
)NKSP_CODE",
        .expectParseError = true // units must match for - operator
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1 - 145s)
end on
)NKSP_CODE",
        .expectParseError = true // units must match for - operator
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1ms - 145mB)
end on
)NKSP_CODE",
        .expectParseError = true // units must match for - operator
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.0ms - 0.1ms)
end on
)NKSP_CODE",
        .expectRealExitResult = 0.9,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.1s - 106.0ms)
end on
)NKSP_CODE",
        .expectRealExitResult = 994.0,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1100.0ms - 0.106s)
end on
)NKSP_CODE",
        .expectRealExitResult = 994.0,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.0s - 145.0)
end on
)NKSP_CODE",
        .expectParseError = true // units must match for - operator
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.0 - 145.0s)
end on
)NKSP_CODE",
        .expectParseError = true // units must match for - operator
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.0ms - 145.0mB)
end on
)NKSP_CODE",
        .expectParseError = true // units must match for - operator
    });

    // 'final' ('!') operator tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!5 - !3)
end on
)NKSP_CODE",
        .expectIntExitResult = 2,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(5 - 3)
end on
)NKSP_CODE",
        .expectIntExitResult = 2,
        .expectExitResultFinal = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!5.9 - !3.3)
end on
)NKSP_CODE",
        .expectRealExitResult = 2.6,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(5.9 - 3.3)
end on
)NKSP_CODE",
        .expectRealExitResult = 2.6,
        .expectExitResultFinal = false
    });

    #if !SILENT_TEST
    std::cout << std::endl;
    #endif
}

static void testModuloOperator() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: modulo (mod) operator\n";
    #endif

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10 mod 8)
end on
)NKSP_CODE",
        .expectIntExitResult = 2
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare $a := 10
  declare $b := 8
  exit($a mod $b)
end on
)NKSP_CODE",
        .expectIntExitResult = 2
    });

    // real number tests ...
    // (mod operator prohibits real numbers ATM)

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10.0 mod 8.0)
end on
)NKSP_CODE",
        .expectParseError = true // mod operator prohibits real numbers ATM
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10 mod 8.0)
end on
)NKSP_CODE",
        .expectParseError = true // mod operator prohibits real numbers ATM
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10.0 mod 8)
end on
)NKSP_CODE",
        .expectParseError = true // mod operator prohibits real numbers ATM
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~a := 10.0
  declare ~b := 8.0
  exit(~a mod ~b)
end on
)NKSP_CODE",
        .expectParseError = true // mod operator prohibits real numbers ATM
    });

    // std unit tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10s mod 8)
end on
)NKSP_CODE",
        .expectParseError = true // mod operator prohibits std units ATM
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10 mod 8s)
end on
)NKSP_CODE",
        .expectParseError = true // mod operator prohibits std units ATM
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10s mod 8s)
end on
)NKSP_CODE",
        .expectParseError = true // mod operator prohibits std units ATM
    });

    // 'final' ('!') operator tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!10 mod !8)
end on
)NKSP_CODE",
        .expectIntExitResult = 2,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10 mod 8)
end on
)NKSP_CODE",
        .expectIntExitResult = 2,
        .expectExitResultFinal = false
    });

    #if !SILENT_TEST
    std::cout << std::endl;
    #endif
}

static void testMultiplyOperator() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: multiply (*) operator\n";
    #endif

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10 * 8)
end on
)NKSP_CODE",
        .expectIntExitResult = 80
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-3 * -4)
end on
)NKSP_CODE",
        .expectIntExitResult = 12
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-52 * 63)
end on
)NKSP_CODE",
        .expectIntExitResult = -3276
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(123 * -59)
end on
)NKSP_CODE",
        .expectIntExitResult = -7257
    });

    // real number tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10.2 * 8.4)
end on
)NKSP_CODE",
        .expectRealExitResult = 85.68
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10.0 * -3.33)
end on
)NKSP_CODE",
        .expectRealExitResult = -33.3
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-3.33 * 10.0)
end on
)NKSP_CODE",
        .expectRealExitResult = -33.3
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-3.33 * -10.0)
end on
)NKSP_CODE",
        .expectRealExitResult = 33.3
    });

    // mixed type tests ...
    // (mixed int * real forbidden ATM)

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(2 * 3.0)
end on
)NKSP_CODE",
        .expectParseError = true // mixed int * real forbidden ATM
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(2.0 * 3)
end on
)NKSP_CODE",
        .expectParseError = true // mixed int * real forbidden ATM
    });

    // std unit tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10ms * 8)
end on
)NKSP_CODE",
        .expectIntExitResult = 80,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10 * 8ms)
end on
)NKSP_CODE",
        .expectIntExitResult = 80,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10s * 8s)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides not allowed for * ATM
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10cs * 8d)
end on
)NKSP_CODE",
        .expectIntExitResult = 80,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10m * 8ms)
end on
)NKSP_CODE",
        .expectIntExitResult = 80,
        .expectExitResultUnitPrefix = { VM_MICRO },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10ms * 8k)
end on
)NKSP_CODE",
        .expectIntExitResult = 80,
        .expectExitResultUnitPrefix = { VM_NO_PREFIX },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10.1ms * 8.0)
end on
)NKSP_CODE",
        .expectRealExitResult = 80.8,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10.1 * 8.0ms)
end on
)NKSP_CODE",
        .expectRealExitResult = 80.8,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10.0s * 8.0s)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides not allowed for * ATM
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10.1ds * 8.0c)
end on
)NKSP_CODE",
        .expectRealExitResult = 80.8,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10.1m * 8.0ms)
end on
)NKSP_CODE",
        .expectRealExitResult = 80.8,
        .expectExitResultUnitPrefix = { VM_MICRO },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10.1m * 8.0ks)
end on
)NKSP_CODE",
        .expectRealExitResult = 80.8,
        .expectExitResultUnitPrefix = { VM_NO_PREFIX },
        .expectExitResultUnit = VM_SECOND
    });

    // 'final' ('!') operator tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!10 * !8)
end on
)NKSP_CODE",
        .expectIntExitResult = 80,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10 * 8)
end on
)NKSP_CODE",
        .expectIntExitResult = 80,
        .expectExitResultFinal = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!10 * 8)
end on
)NKSP_CODE",
        .expectIntExitResult = 80,
        .expectExitResultFinal = true,
        .expectParseWarning = true // since final only on one side, result will be final though
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10 * !8)
end on
)NKSP_CODE",
        .expectIntExitResult = 80,
        .expectExitResultFinal = true,
        .expectParseWarning = true // since final only on one side, result will be final though
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!10.1 * !8.0)
end on
)NKSP_CODE",
        .expectRealExitResult = 80.8,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10.1 * 8.0)
end on
)NKSP_CODE",
        .expectRealExitResult = 80.8,
        .expectExitResultFinal = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!10.1 * 8.0)
end on
)NKSP_CODE",
        .expectRealExitResult = 80.8,
        .expectExitResultFinal = true,
        .expectParseWarning = true // since final only on one side, result will be final though
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(10.1 * !8.0)
end on
)NKSP_CODE",
        .expectRealExitResult = 80.8,
        .expectExitResultFinal = true,
        .expectParseWarning = true // since final only on one side, result will be final though
    });

    #if !SILENT_TEST
    std::cout << std::endl;
    #endif
}

static void testDivideOperator() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: divide (/) operator\n";
    #endif

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9 / 3)
end on
)NKSP_CODE",
        .expectIntExitResult = 3
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-27 / 3)
end on
)NKSP_CODE",
        .expectIntExitResult = -9
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(35 / -5)
end on
)NKSP_CODE",
        .expectIntExitResult = -7
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(39 / -5)
end on
)NKSP_CODE",
        .expectIntExitResult = -7
    });

    // real number tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9.0 / 10.0)
end on
)NKSP_CODE",
        .expectRealExitResult = 0.9
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-9.0 / 10.0)
end on
)NKSP_CODE",
        .expectRealExitResult = -0.9
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9.0 / -10.0)
end on
)NKSP_CODE",
        .expectRealExitResult = -0.9
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-9.0 / -10.0)
end on
)NKSP_CODE",
        .expectRealExitResult = 0.9
    });

    // mixed type tests ...
    // (mixed int / real forbidden ATM)

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9 / 10.0)
end on
)NKSP_CODE",
        .expectParseError = true // mixed int / real forbidden ATM
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9.0 / 10)
end on
)NKSP_CODE",
        .expectParseError = true // mixed int / real forbidden ATM
    });

    // std unit tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-27us / 3)
end on
)NKSP_CODE",
        .expectIntExitResult = -9,
        .expectExitResultUnitPrefix = { VM_MICRO },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-27mdB / 3mdB)
end on
)NKSP_CODE",
        .expectIntExitResult = -9,
        .expectExitResultUnitPrefix = { VM_NO_PREFIX },
        .expectExitResultUnit = VM_NO_UNIT
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-27s / 3m)
end on
)NKSP_CODE",
        .expectIntExitResult = -9,
        .expectExitResultUnitPrefix = { VM_KILO },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-27us / 3m)
end on
)NKSP_CODE",
        .expectIntExitResult = -9,
        .expectExitResultUnitPrefix = { VM_MILLI },
        .expectExitResultUnit = VM_SECOND
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-27 / 3s)
end on
)NKSP_CODE",
        .expectParseError = true // illegal unit type arrangement for divisions
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-27s / 3Hz)
end on
)NKSP_CODE",
        .expectParseError = true // unit types are not matching
    });

    // 'final' ('!') operator tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!-27 / !3)
end on
)NKSP_CODE",
        .expectIntExitResult = -9,
        .expectExitResultFinal = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-27 / 3)
end on
)NKSP_CODE",
        .expectIntExitResult = -9,
        .expectExitResultFinal = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!-27 / 3)
end on
)NKSP_CODE",
        .expectIntExitResult = -9,
        .expectExitResultFinal = true,
        .expectParseWarning = true // final only on one side, result will be final though
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-27 / !3)
end on
)NKSP_CODE",
        .expectIntExitResult = -9,
        .expectExitResultFinal = true,
        .expectParseWarning = true // final only on one side, result will be final though
    });

    #if !SILENT_TEST
    std::cout << std::endl;
    #endif
}

static void testSmallerThanOperator() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: smaller than (<) operator\n";
    #endif

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 < 4)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4 < 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4 < 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 < -4)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(123 < -45)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-45 < 123)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    // real number tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 < 4.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4.0 < 3.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.2 < 1.23)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.23 < 1.2)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4.0 < 3.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 < -4.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(123.0 < -45.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-45.0 < 123.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    // mixed type tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9 < 9.1)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9.1 < 9)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    // std unit tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(13ms < 14ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(14ms < 13ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s < 990ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(990ms < 1s)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1000ms < 1s)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s < 1000ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s < 1)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1 < 1s)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1Hz < 1B)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(13.0ms < 13.1ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(13.1ms < 13.0ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(0.9s < 600.0ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(600.0ms < 0.9s)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(5.1kHz < 5100.0Hz)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(5100.0Hz < 5.1kHz)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.0Hz < 1.1)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.2 < 1.34mdB)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9.23us < 3.14kHz)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    // 'final' ('!') operator tests ...
    // (should always yield in false for relation operators)

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!-4 < !3)
end on
)NKSP_CODE",
        .expectBoolExitResult = true,
        .expectExitResultFinal = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4 < 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = true,
        .expectExitResultFinal = false
    });

    #if !SILENT_TEST
    std::cout << std::endl;
    #endif
}

static void testGreaterThanOperator() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: greater than (>) operator\n";
    #endif

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 > 4)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4 > 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4 > 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 > -4)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(123 > -45)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-45 > 123)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    // real number tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 > 4.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4.0 > 3.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.2 > 1.23)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.23 > 1.2)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4.0 > 3.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 > -4.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(123.0 > -45.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-45.0 > 123.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    // mixed type tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9 > 9.1)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9.1 > 9)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    // std unit tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(13ms > 14ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(14ms > 13ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s > 990ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(990ms > 1s)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1000ms > 1s)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s > 1000ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s > 1)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1 > 1s)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1Hz > 1B)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(13.0ms > 13.1ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(13.1ms > 13.0ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(0.9s > 600.0ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(600.0ms > 0.9s)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(5.1kHz > 5100.0Hz)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(5100.0Hz > 5.1kHz)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.0Hz > 1.1)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.2 > 1.34mdB)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9.23us > 3.14kHz)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    // 'final' ('!') operator tests ...
    // (should always yield in false for relation operators)

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!-4 > !3)
end on
)NKSP_CODE",
        .expectBoolExitResult = false,
        .expectExitResultFinal = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4 > 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = false,
        .expectExitResultFinal = false
    });

    #if !SILENT_TEST
    std::cout << std::endl;
    #endif
}

static void testSmallerOrEqualOperator() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: smaller-or-equal (<=) operator\n";
    #endif

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 <= 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4 <= 4)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-23 <= -23)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(23 <= -23)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 <= 4)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4 <= 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4 <= 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 <= -4)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(123 <= -45)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-45 <= 123)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    // real number tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 <= 3.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4.33 <= 4.33)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-23.1 <= -23.1)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(23.3 <= -23.3)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 <= 4.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4.0 <= 3.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4.0 <= 3.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 <= -4.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(123.0 <= -45.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-45.0 <= 123.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    // mixed type tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9 <= 9.1)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9.1 <= 9)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9 <= 9.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9.0 <= 9)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    // std unit tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(13ms <= 14ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(14ms <= 13ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s <= 990ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(990ms <= 1s)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1000ms <= 1s)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s <= 1000ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s <= 1)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1 <= 1s)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1Hz <= 1B)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(13.0ms <= 13.1ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(13.1ms <= 13.0ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(0.9s <= 600.0ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(600.0ms <= 0.9s)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(5.1kHz <= 5100.0Hz)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(5100.0Hz <= 5.1kHz)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.0Hz <= 1.1)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.2 <= 1.34mdB)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9.23us <= 3.14kHz)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    // 'final' ('!') operator tests ...
    // (should always yield in false for relation operators)

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!-4 <= !3)
end on
)NKSP_CODE",
        .expectBoolExitResult = true,
        .expectExitResultFinal = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4 <= 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = true,
        .expectExitResultFinal = false
    });

    #if !SILENT_TEST
    std::cout << std::endl;
    #endif
}

static void testGreaterOrEqualOperator() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: greater-or-equal (>=) operator\n";
    #endif

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 >= 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4 >= 4)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-23 >= -23)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(23 >= -23)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 >= 4)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4 >= 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4 >= 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 >= -4)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(123 >= -45)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-45 >= 123)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    // real number tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 >= 3.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.1 >= 3.1)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.1 >= 3.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 >= 3.1)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-23.33 >= -23.33)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(23.0 >= -23.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 >= 4.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4.0 >= 3.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4.0 >= 3.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 >= -4.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(123.0 >= -45.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-45.0 >= 123.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    // mixed type tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9 >= 9.1)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9.1 >= 9)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9 >= 9.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9.0 >= 9)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    // std unit tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(13ms >= 14ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(14ms >= 13ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s >= 990ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(990ms >= 1s)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1000ms >= 1s)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s >= 1000ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s >= 1)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1 >= 1s)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1Hz >= 1B)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(13.0ms >= 13.1ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(13.1ms >= 13.0ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(0.9s >= 600.0ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(600.0ms >= 0.9s)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(5.1kHz >= 5100.0Hz)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(5100.0Hz >= 5.1kHz)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.0Hz >= 1.1)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1.2 >= 1.34mdB)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(9.23us >= 3.14kHz)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    // 'final' ('!') operator tests ...
    // (should always yield in false for relation operators)

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!-4 >= !3)
end on
)NKSP_CODE",
        .expectBoolExitResult = false,
        .expectExitResultFinal = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4 >= 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = false,
        .expectExitResultFinal = false
    });

    #if !SILENT_TEST
    std::cout << std::endl;
    #endif
}

static void testEqualOperator() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: equal (=) operator\n";
    #endif

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 = 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4 = 4)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 = 4)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(23 = -23)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    // real number tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 = 3.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4.33 = 4.33)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4.31 = 4.35)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 = 4.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(23.0 = -23.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    // deal with inaccuracy of float point
    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~a := 0.165
  declare ~b := 0.185
  declare ~x := 0.1
  declare ~y := 0.25
  exit(~a + ~b = ~x + ~y) { both sides should actually be 0.35, they slightly deviate both though }
end on
)NKSP_CODE",
        .expectBoolExitResult = true // our implementation of real number equal comparison should take care about floating point tolerance
    });

    // deal with inaccuracy of float point
    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~a := 0.166
  declare ~b := 0.185
  declare ~x := 0.1
  declare ~y := 0.25
  exit(~a + ~b = ~x + ~y) { left side approx. 0.351, right side approx. 0.35 }
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    // mixed type tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(23 = 23.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(23.0 = 23)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(23 = 23.1)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(23.1 = 23)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    // std unit tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(13ms = 14ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(14ms = 13ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s = 1ms)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1ms = 1s)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.14kHz = 3140Hz)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3140Hz = 3.14kHz)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1s = 1)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1 = 1s)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(1Hz = 1B)
end on
)NKSP_CODE",
        .expectParseError = true // units on both sides must match
    });

    // 'final' ('!') operator tests ...
    // (should always yield in false for relation operators)

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(!-4 = !3)
end on
)NKSP_CODE",
        .expectBoolExitResult = false,
        .expectExitResultFinal = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(-4 = 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = false,
        .expectExitResultFinal = false
    });

    #if !SILENT_TEST
    std::cout << std::endl;
    #endif
}

static void testUnequalOperator() {
    #if !SILENT_TEST
    std::cout << "UNIT TEST: unequal (#) operator\n";
    #endif

    // integer tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 # 3)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(4 # 4)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 # 4)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(23 # -23)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    // real number tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.0 # 3.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.14 # 3.14)
end on
)NKSP_CODE",
        .expectBoolExitResult = false
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3.19 # 3.12)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(23.0 # -23.0)
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    // deal with inaccuracy of float point
    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~a := 0.165
  declare ~b := 0.185
  declare ~x := 0.1
  declare ~y := 0.25
        exit(~a + ~b # ~x + ~y) { both sides should actually be 0.35, they slightly deviate both though }
end on
)NKSP_CODE",
        .expectBoolExitResult = false // our implementation of real number unequal comparison should take care about floating point tolerance
    });

    // deal with inaccuracy of float point
    runScript({
        .code = R"NKSP_CODE(
on init
  declare ~a := 0.166
  declare ~b := 0.185
  declare ~x := 0.1
  declare ~y := 0.25
        exit(~a + ~b # ~x + ~y) { left side approx. 0.351, right side approx. 0.35 }
end on
)NKSP_CODE",
        .expectBoolExitResult = true
    });

    // mixed type tests ...

    runScript({
        .code = R"NKSP_CODE(
on init
  exit(3 # 3.0)
end on
)NKSP_CODE",
        .expect