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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3816 - (show annotations) (download)
Fri Aug 28 17:28:48 2020 UTC (3 years, 7 months ago) by schoenebeck
File size: 232408 byte(s)
* NKSP parser: Fixed crash if unary '-' operator was used on a non-number
  data type.

* NKSP parser: Raise parser error if either unary '-' or '+' operator was
  used with a non-number data type.

* Tests: Added test cases for the fixed issues described above.

* Bumped version (2.1.1.svn63).

1 /*
2 * Copyright (c) 2019 - 2020 Christian Schoenebeck
3 *
4 * http://www.linuxsampler.org
5 *
6 * This file is part of LinuxSampler and released under the same terms.
7 * See README file for details.
8 */
9
10 // This file contains automated test cases against the NKSP real-time
11 // instrument script engine.
12
13 #include "../../common/global.h"
14 #include "../../common/optional.h"
15 #include "../../common/RTMath.h"
16 #include "../ScriptVM.h"
17 #include "../common.h"
18 #include <sstream>
19 #include <stdlib.h>
20 #include <time.h>
21 #include <assert.h>
22 #include <functional>
23
24 #ifndef TEST_ASSERT
25 # define TEST_ASSERT assert
26 #endif
27
28 #define TEST_VERIFY(...) \
29 if (!(__VA_ARGS__)) { \
30 fprintf(stderr, "\n[ERROR]: The following NKSP test has failed:\n%s\n", \
31 opt.code.c_str()); \
32 fprintf(stderr, "Violated expectation for this failure was: " #__VA_ARGS__ "\n\n"); \
33 fprintf(stderr, "The overall expectations for this failed NKSP test were:\n\n"); \
34 printExpectations(opt); \
35 fprintf(stderr, "\n"); \
36 } \
37 TEST_ASSERT(__VA_ARGS__); \
38
39 #define TEST_PRINT_BOOL_EXPECTATION(e) \
40 printf(#e ": %s\n", (opt.e) ? "Yes" : "No"); \
41
42 #define TEST_PRINT_BOOL_EXPECTATION_OR(e,alt) \
43 printf(#e ": %s", (opt.e || opt.alt) ? "Yes" : "No"); \
44 if (!opt.e && opt.alt) { \
45 printf(" (implied by " #alt ")"); \
46 } \
47 printf("\n"); \
48
49 #define TEST_PRINT_BOOL_EXPECTATION_OR2(e,alt1,alt2) \
50 printf(#e ": %s", (opt.e || opt.alt1 || opt.alt2) ? "Yes" : "No"); \
51 if (!opt.e) { \
52 if (opt.alt1 && opt.alt2) { \
53 printf(" (implied by " #alt1 " and " #alt2 ")"); \
54 } else if (opt.alt1) { \
55 printf(" (implied by " #alt1 ")"); \
56 } else if (opt.alt2) { \
57 printf(" (implied by " #alt2 ")"); \
58 } \
59 } \
60 printf("\n"); \
61
62 #define TEST_PRINT_OPTIONAL_EXPECTATION(e) \
63 printf(#e ": %s\n", \
64 (opt.e) ? std::to_string(*opt.e).c_str() : "Not expected"); \
65
66 #define TEST_PRINT_OPTIONAL_STRING_EXPECTATION(e) \
67 printf(#e ": %s\n", \
68 (opt.e) ? ("'" + *opt.e + "'").c_str() : "Not expected"); \
69
70 #define TEST_PRINT_VECTOR_EXPECTATION(e) \
71 if (opt.e.empty()) { \
72 printf(#e ": Not expected\n"); \
73 } else { \
74 for (size_t i = 0; i < opt.e.size(); ++i) { \
75 printf(#e ": %s\n", std::to_string(opt.e[i]).c_str()); \
76 if (i < opt.e.size() - 1) printf(", "); \
77 } \
78 } \
79
80 using namespace LinuxSampler;
81 using namespace std;
82
83 struct RunScriptOpt {
84 String code;
85 bool expectParseError;
86 bool expectParseWarning;
87 bool expectRuntimeError;
88 bool expectNoExitResult;
89 bool expectExitResultIsInt;
90 bool expectExitResultIsReal;
91 bool prohibitExitFunctionArguments;
92 optional<vmint> expectIntExitResult;
93 optional<bool> expectBoolExitResult;
94 optional<vmfloat> expectRealExitResult;
95 optional<String> expectStringExitResult;
96 vector<MetricPrefix_t> expectExitResultUnitPrefix;
97 optional<StdUnit_t> expectExitResultUnit;
98 optional<bool> expectExitResultFinal;
99 };
100
101 static void printExpectations(RunScriptOpt opt) {
102 TEST_PRINT_BOOL_EXPECTATION(expectParseError);
103 TEST_PRINT_BOOL_EXPECTATION(expectParseWarning);
104 TEST_PRINT_BOOL_EXPECTATION(expectRuntimeError);
105 TEST_PRINT_BOOL_EXPECTATION(expectNoExitResult);
106 TEST_PRINT_BOOL_EXPECTATION_OR2(expectExitResultIsInt, /* Or: */ expectIntExitResult, expectBoolExitResult);
107 TEST_PRINT_BOOL_EXPECTATION_OR(expectExitResultIsReal, /* Or: */ expectRealExitResult);
108 TEST_PRINT_BOOL_EXPECTATION(prohibitExitFunctionArguments);
109 TEST_PRINT_OPTIONAL_EXPECTATION(expectIntExitResult);
110 TEST_PRINT_OPTIONAL_EXPECTATION(expectBoolExitResult);
111 TEST_PRINT_OPTIONAL_EXPECTATION(expectRealExitResult);
112 TEST_PRINT_OPTIONAL_STRING_EXPECTATION(expectStringExitResult);
113 TEST_PRINT_VECTOR_EXPECTATION(expectExitResultUnitPrefix);
114 TEST_PRINT_OPTIONAL_EXPECTATION(expectExitResultUnit);
115 TEST_PRINT_OPTIONAL_EXPECTATION(expectExitResultFinal);
116 }
117
118 static void runScript(const RunScriptOpt& opt) {
119 ScriptVM vm;
120 vm.setAutoSuspendEnabled(false);
121 if (!opt.prohibitExitFunctionArguments)
122 vm.setExitResultEnabled(true);
123 unique_ptr<VMParserContext> parserCtx(
124 vm.loadScript(opt.code)
125 );
126 vector<ParserIssue> errors = parserCtx->errors();
127 vector<ParserIssue> warnings = parserCtx->warnings();
128 if (opt.expectParseError) {
129 TEST_VERIFY(!errors.empty());
130 return;
131 } else {
132 for (ParserIssue& err : errors) {
133 err.dump();
134 }
135 TEST_VERIFY(errors.empty());
136 }
137 if (opt.expectParseWarning) {
138 TEST_VERIFY(!warnings.empty());
139 } else {
140 for (ParserIssue& wrn : warnings) {
141 wrn.dump();
142 }
143 }
144 TEST_VERIFY(parserCtx->eventHandler(0));
145 unique_ptr<VMExecContext> execCtx(
146 vm.createExecContext(&*parserCtx)
147 );
148 for (int i = 0; parserCtx->eventHandler(i); ++i) {
149 VMEventHandler* handler = parserCtx->eventHandler(i);
150 VMExecStatus_t result = vm.exec(&*parserCtx, &*execCtx, handler);
151 if (opt.expectRuntimeError) {
152 TEST_VERIFY(result & VM_EXEC_ERROR);
153 } else {
154 TEST_VERIFY(!(result & VM_EXEC_ERROR));
155 }
156 if (opt.expectNoExitResult) {
157 VMExpr* resExpr = execCtx->exitResult();
158 TEST_VERIFY(!resExpr);
159 }
160 if (opt.expectExitResultIsInt) {
161 VMExpr* resExpr = execCtx->exitResult();
162 TEST_VERIFY(resExpr);
163 TEST_VERIFY(resExpr->exprType() == INT_EXPR);
164 }
165 if (opt.expectExitResultIsReal) {
166 VMExpr* resExpr = execCtx->exitResult();
167 TEST_VERIFY(resExpr);
168 TEST_VERIFY(resExpr->exprType() == REAL_EXPR);
169 }
170 if (opt.expectIntExitResult) {
171 VMExpr* resExpr = execCtx->exitResult();
172 TEST_VERIFY(resExpr);
173 TEST_VERIFY(resExpr->exprType() == INT_EXPR);
174 TEST_VERIFY(resExpr->asInt()->evalInt() == *opt.expectIntExitResult);
175 }
176 if (opt.expectRealExitResult) {
177 VMExpr* resExpr = execCtx->exitResult();
178 TEST_VERIFY(resExpr);
179 TEST_VERIFY(resExpr->exprType() == REAL_EXPR);
180 if (sizeof(vmfloat) == sizeof(float)) {
181 TEST_VERIFY(RTMath::fEqual32(resExpr->asReal()->evalReal(), *opt.expectRealExitResult));
182 } else {
183 TEST_VERIFY(RTMath::fEqual64(resExpr->asReal()->evalReal(), *opt.expectRealExitResult));
184 }
185 }
186 if (opt.expectBoolExitResult) {
187 VMExpr* resExpr = execCtx->exitResult();
188 TEST_VERIFY(resExpr);
189 TEST_VERIFY(resExpr->exprType() == INT_EXPR);
190 TEST_VERIFY(bool(resExpr->asInt()->evalInt()) == *opt.expectBoolExitResult);
191 }
192 if (opt.expectStringExitResult) {
193 VMExpr* resExpr = execCtx->exitResult();
194 TEST_VERIFY(resExpr);
195 TEST_VERIFY(resExpr->exprType() == STRING_EXPR);
196 TEST_VERIFY(resExpr->asString()->evalStr() == *opt.expectStringExitResult);
197 }
198 if (opt.expectExitResultUnit) {
199 VMExpr* resExpr = execCtx->exitResult();
200 TEST_VERIFY(resExpr);
201 VMNumberExpr* numberExpr = resExpr->asNumber();
202 TEST_VERIFY(numberExpr);
203 TEST_VERIFY(numberExpr->unitType() == *opt.expectExitResultUnit);
204 }
205 if (!opt.expectExitResultUnitPrefix.empty()) {
206 VMExpr* resExpr = execCtx->exitResult();
207 TEST_VERIFY(resExpr);
208 VMNumberExpr* numberExpr = resExpr->asNumber();
209 TEST_VERIFY(numberExpr);
210 auto prefixes = opt.expectExitResultUnitPrefix;
211 if (*prefixes.rbegin() != VM_NO_PREFIX)
212 prefixes.push_back(VM_NO_PREFIX); // VM_NO_PREFIX termination required by unitFactr() call
213 vmfloat expectedFactor = VMUnit::unitFactor(&prefixes[0]);
214 vmfloat actualFactor = numberExpr->unitFactor();
215 if (sizeof(vmfloat) == sizeof(float)) {
216 TEST_VERIFY(RTMath::fEqual32(expectedFactor, actualFactor));
217 } else {
218 TEST_VERIFY(RTMath::fEqual64(expectedFactor, actualFactor));
219 }
220 }
221 if (opt.expectExitResultFinal) {
222 VMExpr* resExpr = execCtx->exitResult();
223 TEST_VERIFY(resExpr);
224 VMNumberExpr* numberExpr = resExpr->asNumber();
225 TEST_VERIFY(numberExpr);
226 TEST_VERIFY(numberExpr->isFinal() == *opt.expectExitResultFinal);
227 }
228 }
229 }
230
231 static void testBuiltInExitFunction() {
232 #if !SILENT_TEST
233 std::cout << "UNIT TEST: built-in exit() function\n";
234 #endif
235
236 runScript({
237 .code = R"NKSP_CODE(
238 on init
239 end on
240 )NKSP_CODE",
241 .expectNoExitResult = true
242 });
243
244 runScript({
245 .code = R"NKSP_CODE(
246 on init
247 exit
248 end on
249 )NKSP_CODE",
250 .expectNoExitResult = true
251 });
252
253 runScript({
254 .code = R"NKSP_CODE(
255 on init
256 exit()
257 end on
258 )NKSP_CODE",
259 .expectNoExitResult = true
260 });
261
262 // integer tests ...
263
264 runScript({
265 .code = R"NKSP_CODE(
266 on init
267 exit(42)
268 end on
269 )NKSP_CODE",
270 .expectIntExitResult = 42
271 });
272
273 runScript({
274 .code = R"NKSP_CODE(
275 on init
276 declare $foo := 1
277 if ($foo)
278 exit(21)
279 end if
280 end on
281 )NKSP_CODE",
282 .expectIntExitResult = 21
283 });
284
285 runScript({
286 .code = R"NKSP_CODE(
287 on init
288 declare $foo := 0
289 if ($foo)
290 exit(21)
291 end if
292 exit(99)
293 end on
294 )NKSP_CODE",
295 .expectIntExitResult = 99
296 });
297
298 // string tests ...
299
300 runScript({
301 .code = R"NKSP_CODE(
302 on init
303 exit("fourtytwo!")
304 end on
305 )NKSP_CODE",
306 .expectStringExitResult = "fourtytwo!"
307 });
308
309 // in production environment we prohibit the built-in exit() function to
310 // accept any arguments
311 runScript({
312 .code = R"NKSP_CODE(
313 on init
314 exit(42)
315 end on
316 )NKSP_CODE",
317 .expectParseError = true, // see comment above why
318 .prohibitExitFunctionArguments = true // simulate production environment
319 });
320
321 // real number tests ...
322
323 runScript({
324 .code = R"NKSP_CODE(
325 on init
326 exit(3.14)
327 end on
328 )NKSP_CODE",
329 .expectRealExitResult = 3.14
330 });
331
332 runScript({
333 .code = R"NKSP_CODE(
334 on init
335 declare $foo := 1
336 if ($foo)
337 exit(3.14)
338 end if
339 end on
340 )NKSP_CODE",
341 .expectRealExitResult = 3.14
342 });
343
344 runScript({
345 .code = R"NKSP_CODE(
346 on init
347 declare $foo := 0
348 if ($foo)
349 exit(3.14)
350 end if
351 exit(6.9)
352 end on
353 )NKSP_CODE",
354 .expectRealExitResult = 6.9
355 });
356
357 // int array tests ...
358
359 runScript({
360 .code = R"NKSP_CODE(
361 on init
362 declare %foo[3]
363 %foo[0] := 21
364 exit(%foo[0])
365 end on
366 )NKSP_CODE",
367 .expectIntExitResult = 21
368 });
369
370 runScript({
371 .code = R"NKSP_CODE(
372 on init
373 declare %foo[3] := ( 12, 23, 34 )
374 exit(%foo[0])
375 end on
376 )NKSP_CODE",
377 .expectIntExitResult = 12
378 });
379
380 runScript({
381 .code = R"NKSP_CODE(
382 on init
383 declare %foo[3] := ( 12, 23, 34 )
384 exit(%foo[1])
385 end on
386 )NKSP_CODE",
387 .expectIntExitResult = 23
388 });
389
390 runScript({
391 .code = R"NKSP_CODE(
392 on init
393 declare %foo[3] := ( 12, 23, 34 )
394 exit(%foo[2])
395 end on
396 )NKSP_CODE",
397 .expectIntExitResult = 34
398 });
399
400 runScript({ // make sure array is entirely initialized with zeroes
401 .code = R"NKSP_CODE(
402 on init
403 declare $i
404 declare $result
405 declare %foo[100]
406 while ($i < 100)
407 $result := $result .or. %foo[$i]
408 inc($i)
409 end while
410 exit($result)
411 end on
412 )NKSP_CODE",
413 .expectIntExitResult = 0
414 });
415
416 // real array tests ...
417
418 runScript({
419 .code = R"NKSP_CODE(
420 on init
421 declare ?foo[3]
422 ?foo[0] := 34.9
423 exit(?foo[0])
424 end on
425 )NKSP_CODE",
426 .expectRealExitResult = 34.9
427 });
428
429 runScript({
430 .code = R"NKSP_CODE(
431 on init
432 declare ?foo[3] := ( 0.3, 23.5, 900.1 )
433 exit(?foo[0])
434 end on
435 )NKSP_CODE",
436 .expectRealExitResult = 0.3
437 });
438
439 runScript({
440 .code = R"NKSP_CODE(
441 on init
442 declare ?foo[3] := ( 0.3, 23.5, 900.1 )
443 exit(?foo[1])
444 end on
445 )NKSP_CODE",
446 .expectRealExitResult = 23.5
447 });
448
449 runScript({
450 .code = R"NKSP_CODE(
451 on init
452 declare ?foo[3] := ( 0.3, 23.5, 900.1 )
453 exit(?foo[2])
454 end on
455 )NKSP_CODE",
456 .expectRealExitResult = 900.1
457 });
458
459 runScript({ // make sure array is entirely initialized with zeroes
460 .code = R"NKSP_CODE(
461 on init
462 declare $i
463 declare ?foo[100]
464 while ($i < 100)
465 if (?foo[$i] # 0.0)
466 exit(-1) { test failed }
467 end if
468 inc($i)
469 end while
470 exit(0) { test succeeded }
471 end on
472 )NKSP_CODE",
473 .expectIntExitResult = 0
474 });
475
476 // std unit tests ...
477
478 runScript({
479 .code = R"NKSP_CODE(
480 on init
481 exit(42s)
482 end on
483 )NKSP_CODE",
484 .expectIntExitResult = 42,
485 .expectExitResultUnit = VM_SECOND
486 });
487
488 runScript({
489 .code = R"NKSP_CODE(
490 on init
491 exit(42Hz)
492 end on
493 )NKSP_CODE",
494 .expectIntExitResult = 42,
495 .expectExitResultUnit = VM_HERTZ
496 });
497
498 runScript({
499 .code = R"NKSP_CODE(
500 on init
501 exit(42B)
502 end on
503 )NKSP_CODE",
504 .expectIntExitResult = 42,
505 .expectExitResultUnit = VM_BEL
506 });
507
508 runScript({
509 .code = R"NKSP_CODE(
510 on init
511 exit(42us)
512 end on
513 )NKSP_CODE",
514 .expectIntExitResult = 42,
515 .expectExitResultUnitPrefix = { VM_MICRO },
516 .expectExitResultUnit = VM_SECOND
517 });
518
519 runScript({
520 .code = R"NKSP_CODE(
521 on init
522 exit(42ms)
523 end on
524 )NKSP_CODE",
525 .expectIntExitResult = 42,
526 .expectExitResultUnitPrefix = { VM_MILLI },
527 .expectExitResultUnit = VM_SECOND
528 });
529
530 runScript({
531 .code = R"NKSP_CODE(
532 on init
533 exit(42cs)
534 end on
535 )NKSP_CODE",
536 .expectIntExitResult = 42,
537 .expectExitResultUnitPrefix = { VM_CENTI },
538 .expectExitResultUnit = VM_SECOND
539 });
540
541 runScript({
542 .code = R"NKSP_CODE(
543 on init
544 exit(42ds)
545 end on
546 )NKSP_CODE",
547 .expectIntExitResult = 42,
548 .expectExitResultUnitPrefix = { VM_DECI },
549 .expectExitResultUnit = VM_SECOND
550 });
551
552 runScript({
553 .code = R"NKSP_CODE(
554 on init
555 exit(42das)
556 end on
557 )NKSP_CODE",
558 .expectIntExitResult = 42,
559 .expectExitResultUnitPrefix = { VM_DECA },
560 .expectExitResultUnit = VM_SECOND
561 });
562
563 runScript({
564 .code = R"NKSP_CODE(
565 on init
566 exit(42hs)
567 end on
568 )NKSP_CODE",
569 .expectIntExitResult = 42,
570 .expectExitResultUnitPrefix = { VM_HECTO },
571 .expectExitResultUnit = VM_SECOND
572 });
573
574 runScript({
575 .code = R"NKSP_CODE(
576 on init
577 exit(42ks)
578 end on
579 )NKSP_CODE",
580 .expectIntExitResult = 42,
581 .expectExitResultUnitPrefix = { VM_KILO },
582 .expectExitResultUnit = VM_SECOND
583 });
584
585 runScript({
586 .code = R"NKSP_CODE(
587 on init
588 exit(42s)
589 end on
590 )NKSP_CODE",
591 .expectIntExitResult = 42,
592 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
593 .expectExitResultUnit = VM_SECOND
594 });
595
596 runScript({
597 .code = R"NKSP_CODE(
598 on init
599 exit(42uHz)
600 end on
601 )NKSP_CODE",
602 .expectIntExitResult = 42,
603 .expectExitResultUnitPrefix = { VM_MICRO },
604 .expectExitResultUnit = VM_HERTZ
605 });
606
607 runScript({
608 .code = R"NKSP_CODE(
609 on init
610 exit(42mHz)
611 end on
612 )NKSP_CODE",
613 .expectIntExitResult = 42,
614 .expectExitResultUnitPrefix = { VM_MILLI },
615 .expectExitResultUnit = VM_HERTZ
616 });
617
618 runScript({
619 .code = R"NKSP_CODE(
620 on init
621 exit(42cHz)
622 end on
623 )NKSP_CODE",
624 .expectIntExitResult = 42,
625 .expectExitResultUnitPrefix = { VM_CENTI },
626 .expectExitResultUnit = VM_HERTZ
627 });
628
629 runScript({
630 .code = R"NKSP_CODE(
631 on init
632 exit(42dHz)
633 end on
634 )NKSP_CODE",
635 .expectIntExitResult = 42,
636 .expectExitResultUnitPrefix = { VM_DECI },
637 .expectExitResultUnit = VM_HERTZ
638 });
639
640 runScript({
641 .code = R"NKSP_CODE(
642 on init
643 exit(42daHz)
644 end on
645 )NKSP_CODE",
646 .expectIntExitResult = 42,
647 .expectExitResultUnitPrefix = { VM_DECA },
648 .expectExitResultUnit = VM_HERTZ
649 });
650
651 runScript({
652 .code = R"NKSP_CODE(
653 on init
654 exit(42hHz)
655 end on
656 )NKSP_CODE",
657 .expectIntExitResult = 42,
658 .expectExitResultUnitPrefix = { VM_HECTO },
659 .expectExitResultUnit = VM_HERTZ
660 });
661
662 runScript({
663 .code = R"NKSP_CODE(
664 on init
665 exit(42kHz)
666 end on
667 )NKSP_CODE",
668 .expectIntExitResult = 42,
669 .expectExitResultUnitPrefix = { VM_KILO },
670 .expectExitResultUnit = VM_HERTZ
671 });
672
673 runScript({
674 .code = R"NKSP_CODE(
675 on init
676 exit(42Hz)
677 end on
678 )NKSP_CODE",
679 .expectIntExitResult = 42,
680 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
681 .expectExitResultUnit = VM_HERTZ
682 });
683
684 runScript({
685 .code = R"NKSP_CODE(
686 on init
687 exit(42uB)
688 end on
689 )NKSP_CODE",
690 .expectIntExitResult = 42,
691 .expectExitResultUnitPrefix = { VM_MICRO },
692 .expectExitResultUnit = VM_BEL
693 });
694
695 runScript({
696 .code = R"NKSP_CODE(
697 on init
698 exit(42mB)
699 end on
700 )NKSP_CODE",
701 .expectIntExitResult = 42,
702 .expectExitResultUnitPrefix = { VM_MILLI },
703 .expectExitResultUnit = VM_BEL
704 });
705
706 runScript({
707 .code = R"NKSP_CODE(
708 on init
709 exit(42cB)
710 end on
711 )NKSP_CODE",
712 .expectIntExitResult = 42,
713 .expectExitResultUnitPrefix = { VM_CENTI },
714 .expectExitResultUnit = VM_BEL
715 });
716
717 runScript({
718 .code = R"NKSP_CODE(
719 on init
720 exit(42dB)
721 end on
722 )NKSP_CODE",
723 .expectIntExitResult = 42,
724 .expectExitResultUnitPrefix = { VM_DECI },
725 .expectExitResultUnit = VM_BEL
726 });
727
728 runScript({
729 .code = R"NKSP_CODE(
730 on init
731 exit(42daB)
732 end on
733 )NKSP_CODE",
734 .expectIntExitResult = 42,
735 .expectExitResultUnitPrefix = { VM_DECA },
736 .expectExitResultUnit = VM_BEL
737 });
738
739 runScript({
740 .code = R"NKSP_CODE(
741 on init
742 exit(42hB)
743 end on
744 )NKSP_CODE",
745 .expectIntExitResult = 42,
746 .expectExitResultUnitPrefix = { VM_HECTO },
747 .expectExitResultUnit = VM_BEL
748 });
749
750 runScript({
751 .code = R"NKSP_CODE(
752 on init
753 exit(42kB)
754 end on
755 )NKSP_CODE",
756 .expectIntExitResult = 42,
757 .expectExitResultUnitPrefix = { VM_KILO },
758 .expectExitResultUnit = VM_BEL
759 });
760
761 runScript({
762 .code = R"NKSP_CODE(
763 on init
764 exit(42B)
765 end on
766 )NKSP_CODE",
767 .expectIntExitResult = 42,
768 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
769 .expectExitResultUnit = VM_BEL
770 });
771
772 runScript({
773 .code = R"NKSP_CODE(
774 on init
775 exit(42udB)
776 end on
777 )NKSP_CODE",
778 .expectIntExitResult = 42,
779 .expectExitResultUnitPrefix = { VM_MICRO, VM_DECI },
780 .expectExitResultUnit = VM_BEL
781 });
782
783 runScript({
784 .code = R"NKSP_CODE(
785 on init
786 exit(42mdB)
787 end on
788 )NKSP_CODE",
789 .expectIntExitResult = 42,
790 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
791 .expectExitResultUnit = VM_BEL
792 });
793
794 runScript({
795 .code = R"NKSP_CODE(
796 on init
797 exit(42cdB)
798 end on
799 )NKSP_CODE",
800 .expectIntExitResult = 42,
801 .expectExitResultUnitPrefix = { VM_CENTI, VM_DECI },
802 .expectExitResultUnit = VM_BEL
803 });
804
805 runScript({
806 .code = R"NKSP_CODE(
807 on init
808 exit(42ddB)
809 end on
810 )NKSP_CODE",
811 .expectIntExitResult = 42,
812 .expectExitResultUnitPrefix = { VM_DECI, VM_DECI },
813 .expectExitResultUnit = VM_BEL
814 });
815
816 runScript({
817 .code = R"NKSP_CODE(
818 on init
819 exit(42dadB)
820 end on
821 )NKSP_CODE",
822 .expectIntExitResult = 42,
823 .expectExitResultUnitPrefix = { VM_DECA, VM_DECI },
824 .expectExitResultUnit = VM_BEL
825 });
826
827 runScript({
828 .code = R"NKSP_CODE(
829 on init
830 exit(42hdB)
831 end on
832 )NKSP_CODE",
833 .expectIntExitResult = 42,
834 .expectExitResultUnitPrefix = { VM_HECTO, VM_DECI },
835 .expectExitResultUnit = VM_BEL
836 });
837
838 runScript({
839 .code = R"NKSP_CODE(
840 on init
841 exit(42kdB)
842 end on
843 )NKSP_CODE",
844 .expectIntExitResult = 42,
845 .expectExitResultUnitPrefix = { VM_KILO, VM_DECI },
846 .expectExitResultUnit = VM_BEL
847 });
848
849 runScript({
850 .code = R"NKSP_CODE(
851 on init
852 declare $foo := 42mdB
853 exit($foo)
854 end on
855 )NKSP_CODE",
856 .expectIntExitResult = 42,
857 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
858 .expectExitResultUnit = VM_BEL
859 });
860
861 runScript({
862 .code = R"NKSP_CODE(
863 on init
864 exit(3.14s)
865 end on
866 )NKSP_CODE",
867 .expectRealExitResult = 3.14,
868 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
869 .expectExitResultUnit = VM_SECOND
870 });
871
872 runScript({
873 .code = R"NKSP_CODE(
874 on init
875 exit(3.14us)
876 end on
877 )NKSP_CODE",
878 .expectRealExitResult = 3.14,
879 .expectExitResultUnitPrefix = { VM_MICRO },
880 .expectExitResultUnit = VM_SECOND
881 });
882
883 runScript({
884 .code = R"NKSP_CODE(
885 on init
886 exit(3.14ms)
887 end on
888 )NKSP_CODE",
889 .expectRealExitResult = 3.14,
890 .expectExitResultUnitPrefix = { VM_MILLI },
891 .expectExitResultUnit = VM_SECOND
892 });
893
894 runScript({
895 .code = R"NKSP_CODE(
896 on init
897 exit(-0.1B)
898 end on
899 )NKSP_CODE",
900 .expectRealExitResult = -0.1,
901 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
902 .expectExitResultUnit = VM_BEL
903 });
904
905 runScript({
906 .code = R"NKSP_CODE(
907 on init
908 exit(-0.1dB)
909 end on
910 )NKSP_CODE",
911 .expectRealExitResult = -0.1,
912 .expectExitResultUnitPrefix = { VM_DECI },
913 .expectExitResultUnit = VM_BEL
914 });
915
916 runScript({
917 .code = R"NKSP_CODE(
918 on init
919 exit(-0.1mdB)
920 end on
921 )NKSP_CODE",
922 .expectRealExitResult = -0.1,
923 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
924 .expectExitResultUnit = VM_BEL
925 });
926
927 runScript({
928 .code = R"NKSP_CODE(
929 on init
930 declare ~foo := -0.1mdB
931 exit(~foo)
932 end on
933 )NKSP_CODE",
934 .expectRealExitResult = -0.1,
935 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
936 .expectExitResultUnit = VM_BEL
937 });
938
939 runScript({
940 .code = R"NKSP_CODE(
941 on init
942 declare ~foo := 0.0dB
943 ~foo := -0.1mdB
944 exit(~foo)
945 end on
946 )NKSP_CODE",
947 .expectRealExitResult = -0.1,
948 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
949 .expectExitResultUnit = VM_BEL
950 });
951
952 runScript({
953 .code = R"NKSP_CODE(
954 on init
955 declare ~foo := 0.0dB
956 ~foo := -0.1Hz
957 exit(~foo)
958 end on
959 )NKSP_CODE",
960 .expectParseError = true // assigning different unit type to a variable is not allowed
961 });
962
963 // 'final' ('!') operator tests ...
964
965 runScript({
966 .code = R"NKSP_CODE(
967 on init
968 exit(!42)
969 end on
970 )NKSP_CODE",
971 .expectIntExitResult = 42,
972 .expectExitResultFinal = true
973 });
974
975 runScript({
976 .code = R"NKSP_CODE(
977 on init
978 exit(42)
979 end on
980 )NKSP_CODE",
981 .expectIntExitResult = 42,
982 .expectExitResultFinal = false
983 });
984
985 runScript({
986 .code = R"NKSP_CODE(
987 on init
988 declare $foo := !42
989 exit($foo)
990 end on
991 )NKSP_CODE",
992 .expectIntExitResult = 42,
993 .expectExitResultFinal = true
994 });
995
996 runScript({
997 .code = R"NKSP_CODE(
998 on init
999 declare $foo := 42
1000 exit($foo)
1001 end on
1002 )NKSP_CODE",
1003 .expectIntExitResult = 42,
1004 .expectExitResultFinal = false
1005 });
1006
1007 runScript({
1008 .code = R"NKSP_CODE(
1009 on init
1010 declare ~foo := !3.14
1011 exit(~foo)
1012 end on
1013 )NKSP_CODE",
1014 .expectRealExitResult = 3.14,
1015 .expectExitResultFinal = true
1016 });
1017
1018 runScript({
1019 .code = R"NKSP_CODE(
1020 on init
1021 declare ~foo := 3.14
1022 exit(~foo)
1023 end on
1024 )NKSP_CODE",
1025 .expectRealExitResult = 3.14,
1026 .expectExitResultFinal = false
1027 });
1028
1029 runScript({
1030 .code = R"NKSP_CODE(
1031 on init
1032 declare ~foo := !3.14mdB
1033 exit(~foo)
1034 end on
1035 )NKSP_CODE",
1036 .expectRealExitResult = 3.14,
1037 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
1038 .expectExitResultUnit = VM_BEL,
1039 .expectExitResultFinal = true
1040 });
1041
1042 runScript({
1043 .code = R"NKSP_CODE(
1044 on init
1045 declare ~foo := !0.0mdB
1046 ~foo := !3.14mdB
1047 exit(~foo)
1048 end on
1049 )NKSP_CODE",
1050 .expectRealExitResult = 3.14,
1051 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
1052 .expectExitResultUnit = VM_BEL,
1053 .expectExitResultFinal = true
1054 });
1055
1056 runScript({
1057 .code = R"NKSP_CODE(
1058 on init
1059 declare ~foo := !0.0mdB
1060 ~foo := 3.14mdB
1061 exit(~foo)
1062 end on
1063 )NKSP_CODE",
1064 .expectParseError = true // assigning non-final to a final variable not allowed
1065 });
1066
1067 runScript({
1068 .code = R"NKSP_CODE(
1069 on init
1070 declare ~foo := 0.0mdB
1071 ~foo := !3.14mdB
1072 exit(~foo)
1073 end on
1074 )NKSP_CODE",
1075 .expectParseError = true // assigning final to a non-final variable not allowed
1076 });
1077
1078 // exit() acting as return statement ...
1079
1080 runScript({
1081 .code = R"NKSP_CODE(
1082 function doFoo
1083 exit(2) { just return from this user function, i.e. don't stop init handler }
1084 end function
1085
1086 on init
1087 call doFoo
1088 exit(3)
1089 end on
1090 )NKSP_CODE",
1091 .expectIntExitResult = 3
1092 });
1093
1094 runScript({
1095 .code = R"NKSP_CODE(
1096 function doFoo1
1097 exit(2) { just return from this user function, i.e. don't stop init handler }
1098 end function
1099
1100 function doFoo2
1101 call doFoo1
1102 exit(3) { just return from this user function, i.e. don't stop init handler }
1103 end function
1104
1105 on init
1106 call doFoo2
1107 exit(4)
1108 end on
1109 )NKSP_CODE",
1110 .expectIntExitResult = 4
1111 });
1112
1113 runScript({
1114 .code = R"NKSP_CODE(
1115 function doFoo
1116 exit(2) { just return from this user function, i.e. don't stop init handler }
1117 end function
1118
1119 on init
1120 call doFoo
1121 exit(3)
1122 { dead code ... }
1123 call doFoo
1124 exit(4)
1125 end on
1126 )NKSP_CODE",
1127 .expectIntExitResult = 3
1128 });
1129
1130 runScript({
1131 .code = R"NKSP_CODE(
1132 function doFoo
1133 exit(2) { just return from this user function, i.e. don't stop init handler }
1134 end function
1135
1136 on init
1137 call doFoo
1138 exit(3)
1139 { dead code ... }
1140 call doFoo
1141 end on
1142 )NKSP_CODE",
1143 .expectIntExitResult = 3
1144 });
1145
1146 #if !SILENT_TEST
1147 std::cout << std::endl;
1148 #endif
1149 }
1150
1151 static void testStringConcatOperator() {
1152 #if !SILENT_TEST
1153 std::cout << "UNIT TEST: string concatenation (&) operator\n";
1154 #endif
1155
1156 // strings only tests ...
1157
1158 runScript({
1159 .code = R"NKSP_CODE(
1160 on init
1161 declare @s := "foo" & " bar"
1162 exit(@s)
1163 end on
1164 )NKSP_CODE",
1165 .expectStringExitResult = "foo bar"
1166 });
1167
1168 // integer tests ...
1169
1170 runScript({
1171 .code = R"NKSP_CODE(
1172 on init
1173 declare @s := "foo" & " bar" & " " & 123
1174 exit(@s)
1175 end on
1176 )NKSP_CODE",
1177 .expectStringExitResult = "foo bar 123"
1178 });
1179
1180 runScript({
1181 .code = R"NKSP_CODE(
1182 on init
1183 declare $i := 123
1184 declare @s := "foo" & " bar" & " " & $i
1185 exit(@s)
1186 end on
1187 )NKSP_CODE",
1188 .expectStringExitResult = "foo bar 123"
1189 });
1190
1191 // real number tests ...
1192
1193 runScript({
1194 .code = R"NKSP_CODE(
1195 on init
1196 declare @s := "foo" & " bar" & " " & 1.23
1197 exit(@s)
1198 end on
1199 )NKSP_CODE",
1200 .expectStringExitResult = "foo bar 1.23"
1201 });
1202
1203 runScript({
1204 .code = R"NKSP_CODE(
1205 on init
1206 declare ~r := 3.14
1207 declare @s := "foo" & " bar" & " " & ~r
1208 exit(@s)
1209 end on
1210 )NKSP_CODE",
1211 .expectStringExitResult = "foo bar 3.14"
1212 });
1213
1214 // std unit tests ...
1215
1216 runScript({
1217 .code = R"NKSP_CODE(
1218 on init
1219 declare $i := 500Hz
1220 declare @s := "foo" & " bar" & " " & $i
1221 exit(@s)
1222 end on
1223 )NKSP_CODE",
1224 .expectStringExitResult = "foo bar 500Hz"
1225 });
1226
1227 runScript({
1228 .code = R"NKSP_CODE(
1229 on init
1230 declare ~r := 3.14s
1231 declare @s := "foo" & " bar" & " " & ~r
1232 exit(@s)
1233 end on
1234 )NKSP_CODE",
1235 .expectStringExitResult = "foo bar 3.14s"
1236 });
1237
1238 runScript({
1239 .code = R"NKSP_CODE(
1240 on init
1241 declare ~r := -22.3mdB
1242 declare @s := "foo" & " bar" & " " & ~r
1243 exit(@s)
1244 end on
1245 )NKSP_CODE",
1246 .expectStringExitResult = "foo bar -22.3mdB"
1247 });
1248
1249 runScript({
1250 .code = R"NKSP_CODE(
1251 on init
1252 declare $i := 20us
1253 declare @s := "foo" & " bar" & " " & $i
1254 exit(@s)
1255 end on
1256 )NKSP_CODE",
1257 .expectStringExitResult = "foo bar 20us"
1258 });
1259
1260 runScript({
1261 .code = R"NKSP_CODE(
1262 on init
1263 declare $i := 20kHz
1264 declare @s := "foo" & " bar" & " " & $i
1265 exit(@s)
1266 end on
1267 )NKSP_CODE",
1268 .expectStringExitResult = "foo bar 20kHz"
1269 });
1270
1271 runScript({
1272 .code = R"NKSP_CODE(
1273 on init
1274 declare $i := -6dB
1275 declare @s := "foo" & " bar" & " " & $i
1276 exit(@s)
1277 end on
1278 )NKSP_CODE",
1279 .expectStringExitResult = "foo bar -6dB"
1280 });
1281
1282 runScript({
1283 .code = R"NKSP_CODE(
1284 on init
1285 declare $i := 1us * 1d
1286 declare @s := "foo" & " bar" & " " & $i
1287 exit(@s)
1288 end on
1289 )NKSP_CODE",
1290 .expectStringExitResult = "foo bar 1*10^-7s"
1291 });
1292
1293 runScript({
1294 .code = R"NKSP_CODE(
1295 on init
1296 declare ~r := 12.4mc
1297 declare @s := "foo" & " bar" & " " & ~r
1298 exit(@s)
1299 end on
1300 )NKSP_CODE",
1301 .expectStringExitResult = "foo bar 12.4mc"
1302 });
1303
1304 #if !SILENT_TEST
1305 std::cout << std::endl;
1306 #endif
1307 }
1308
1309 static void testNegOperator() {
1310 #if !SILENT_TEST
1311 std::cout << "UNIT TEST: negate (-) operator\n";
1312 #endif
1313
1314 // integer tests ...
1315
1316 runScript({
1317 .code = R"NKSP_CODE(
1318 on init
1319 exit(-87)
1320 end on
1321 )NKSP_CODE",
1322 .expectIntExitResult = -87
1323 });
1324
1325 runScript({
1326 .code = R"NKSP_CODE(
1327 on init
1328 declare $foo := -87
1329 exit(-$foo)
1330 end on
1331 )NKSP_CODE",
1332 .expectIntExitResult = 87
1333 });
1334
1335 // real number tests ...
1336
1337 runScript({
1338 .code = R"NKSP_CODE(
1339 on init
1340 exit(-99.3)
1341 end on
1342 )NKSP_CODE",
1343 .expectRealExitResult = -99.3
1344 });
1345
1346 runScript({
1347 .code = R"NKSP_CODE(
1348 on init
1349 declare ~foo := -99.3
1350 exit(-~foo)
1351 end on
1352 )NKSP_CODE",
1353 .expectRealExitResult = 99.3
1354 });
1355
1356 // std unit tests
1357
1358 runScript({
1359 .code = R"NKSP_CODE(
1360 on init
1361 declare $foo := -87mdB
1362 exit(-$foo)
1363 end on
1364 )NKSP_CODE",
1365 .expectIntExitResult = 87,
1366 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
1367 .expectExitResultUnit = VM_BEL
1368 });
1369
1370 // 'final' ('!') operator tests ...
1371
1372 runScript({
1373 .code = R"NKSP_CODE(
1374 on init
1375 declare $foo := !-87
1376 exit(-$foo)
1377 end on
1378 )NKSP_CODE",
1379 .expectIntExitResult = 87,
1380 .expectExitResultFinal = true
1381 });
1382
1383 runScript({
1384 .code = R"NKSP_CODE(
1385 on init
1386 declare $foo := -87
1387 exit(-$foo)
1388 end on
1389 )NKSP_CODE",
1390 .expectIntExitResult = 87,
1391 .expectExitResultFinal = false
1392 });
1393
1394 // string tests ...
1395
1396 runScript({
1397 .code = R"NKSP_CODE(
1398 on init
1399 exit(-"text")
1400 end on
1401 )NKSP_CODE",
1402 .expectParseError = true // unary '-' operator requires number
1403 });
1404
1405 runScript({
1406 .code = R"NKSP_CODE(
1407 on init
1408 declare @s := "text"
1409 exit(-@s)
1410 end on
1411 )NKSP_CODE",
1412 .expectParseError = true // unary '-' operator requires number
1413 });
1414
1415 //TODO: the following are unary '+' operator tests which should be moved to their own function (lazy me).
1416
1417 runScript({
1418 .code = R"NKSP_CODE(
1419 on init
1420 exit(+54)
1421 end on
1422 )NKSP_CODE",
1423 .expectIntExitResult = 54
1424 });
1425
1426 runScript({
1427 .code = R"NKSP_CODE(
1428 on init
1429 declare $foo := +54
1430 exit( $foo )
1431 end on
1432 )NKSP_CODE",
1433 .expectIntExitResult = 54
1434 });
1435
1436 runScript({
1437 .code = R"NKSP_CODE(
1438 on init
1439 exit(+0.45)
1440 end on
1441 )NKSP_CODE",
1442 .expectRealExitResult = 0.45
1443 });
1444
1445 runScript({
1446 .code = R"NKSP_CODE(
1447 on init
1448 declare ~foo := +0.29
1449 exit( ~foo )
1450 end on
1451 )NKSP_CODE",
1452 .expectRealExitResult = 0.29
1453 });
1454
1455 // string tests ...
1456
1457 runScript({
1458 .code = R"NKSP_CODE(
1459 on init
1460 exit(+"text")
1461 end on
1462 )NKSP_CODE",
1463 .expectParseError = true // unary '+' operator requires number
1464 });
1465
1466 runScript({
1467 .code = R"NKSP_CODE(
1468 on init
1469 declare @s := "text"
1470 exit(+@s)
1471 end on
1472 )NKSP_CODE",
1473 .expectParseError = true // unary '+' operator requires number
1474 });
1475
1476 #if !SILENT_TEST
1477 std::cout << std::endl;
1478 #endif
1479 }
1480
1481 static void testPlusOperator() {
1482 #if !SILENT_TEST
1483 std::cout << "UNIT TEST: plus (+) operator\n";
1484 #endif
1485
1486 // integer tests ...
1487
1488 runScript({
1489 .code = R"NKSP_CODE(
1490 on init
1491 exit(4 + 3)
1492 end on
1493 )NKSP_CODE",
1494 .expectIntExitResult = 7
1495 });
1496
1497 runScript({
1498 .code = R"NKSP_CODE(
1499 on init
1500 exit(42 + 145)
1501 end on
1502 )NKSP_CODE",
1503 .expectIntExitResult = 187
1504 });
1505
1506 runScript({
1507 .code = R"NKSP_CODE(
1508 on init
1509 exit(-4 + 2)
1510 end on
1511 )NKSP_CODE",
1512 .expectIntExitResult = -2
1513 });
1514
1515 // real number tests ...
1516
1517 runScript({
1518 .code = R"NKSP_CODE(
1519 on init
1520 exit(4.0 + 3.0)
1521 end on
1522 )NKSP_CODE",
1523 .expectRealExitResult = 7.0
1524 });
1525
1526 runScript({
1527 .code = R"NKSP_CODE(
1528 on init
1529 exit(42.3 + 145.2)
1530 end on
1531 )NKSP_CODE",
1532 .expectRealExitResult = 187.5
1533 });
1534
1535 runScript({
1536 .code = R"NKSP_CODE(
1537 on init
1538 exit(-4.0 + 2.2)
1539 end on
1540 )NKSP_CODE",
1541 .expectRealExitResult = -1.8
1542 });
1543
1544 // std unit tests ...
1545
1546 runScript({
1547 .code = R"NKSP_CODE(
1548 on init
1549 exit(42ms + 145ms)
1550 end on
1551 )NKSP_CODE",
1552 .expectIntExitResult = 187,
1553 .expectExitResultUnitPrefix = { VM_MILLI },
1554 .expectExitResultUnit = VM_SECOND
1555 });
1556
1557 runScript({
1558 .code = R"NKSP_CODE(
1559 on init
1560 exit(1s + 145ms)
1561 end on
1562 )NKSP_CODE",
1563 .expectIntExitResult = 1145,
1564 .expectExitResultUnitPrefix = { VM_MILLI },
1565 .expectExitResultUnit = VM_SECOND
1566 });
1567
1568 runScript({
1569 .code = R"NKSP_CODE(
1570 on init
1571 exit(42ms + 145)
1572 end on
1573 )NKSP_CODE",
1574 .expectParseError = true // units must match for + operator
1575 });
1576
1577 runScript({
1578 .code = R"NKSP_CODE(
1579 on init
1580 exit(42 + 145ms)
1581 end on
1582 )NKSP_CODE",
1583 .expectParseError = true // units must match for + operator
1584 });
1585
1586 runScript({
1587 .code = R"NKSP_CODE(
1588 on init
1589 exit(42Hz + 145s)
1590 end on
1591 )NKSP_CODE",
1592 .expectParseError = true // units must match for + operator
1593 });
1594
1595 runScript({
1596 .code = R"NKSP_CODE(
1597 on init
1598 exit(42.1ms + 145.3ms)
1599 end on
1600 )NKSP_CODE",
1601 .expectRealExitResult = 187.4,
1602 .expectExitResultUnitPrefix = { VM_MILLI },
1603 .expectExitResultUnit = VM_SECOND
1604 });
1605
1606 runScript({
1607 .code = R"NKSP_CODE(
1608 on init
1609 exit(1.1s + 145.0ms)
1610 end on
1611 )NKSP_CODE",
1612 .expectRealExitResult = 1245.0,
1613 .expectExitResultUnitPrefix = { VM_MILLI },
1614 .expectExitResultUnit = VM_SECOND
1615 });
1616
1617 runScript({
1618 .code = R"NKSP_CODE(
1619 on init
1620 exit(42.1ms + 145.3)
1621 end on
1622 )NKSP_CODE",
1623 .expectParseError = true // units must match for + operator
1624 });
1625
1626 runScript({
1627 .code = R"NKSP_CODE(
1628 on init
1629 exit(42.0 + 145.0ms)
1630 end on
1631 )NKSP_CODE",
1632 .expectParseError = true // units must match for + operator
1633 });
1634
1635 runScript({
1636 .code = R"NKSP_CODE(
1637 on init
1638 exit(42.0Hz + 145.0s)
1639 end on
1640 )NKSP_CODE",
1641 .expectParseError = true // units must match for + operator
1642 });
1643
1644 // 'final' ('!') operator tests ...
1645
1646 runScript({
1647 .code = R"NKSP_CODE(
1648 on init
1649 exit(!4 + !3)
1650 end on
1651 )NKSP_CODE",
1652 .expectIntExitResult = 7,
1653 .expectExitResultFinal = true
1654 });
1655
1656 runScript({
1657 .code = R"NKSP_CODE(
1658 on init
1659 exit(4 + 3)
1660 end on
1661 )NKSP_CODE",
1662 .expectIntExitResult = 7,
1663 .expectExitResultFinal = false
1664 });
1665
1666 runScript({
1667 .code = R"NKSP_CODE(
1668 on init
1669 exit(!4.1 + !3.3)
1670 end on
1671 )NKSP_CODE",
1672 .expectRealExitResult = 7.4,
1673 .expectExitResultFinal = true
1674 });
1675
1676 runScript({
1677 .code = R"NKSP_CODE(
1678 on init
1679 exit(4.1 + 3.3)
1680 end on
1681 )NKSP_CODE",
1682 .expectRealExitResult = 7.4,
1683 .expectExitResultFinal = false
1684 });
1685
1686 #if !SILENT_TEST
1687 std::cout << std::endl;
1688 #endif
1689 }
1690
1691 static void testMinusOperator() {
1692 #if !SILENT_TEST
1693 std::cout << "UNIT TEST: minus (-) operator\n";
1694 #endif
1695
1696 // integer tests ...
1697
1698 runScript({
1699 .code = R"NKSP_CODE(
1700 on init
1701 exit(4 - 3)
1702 end on
1703 )NKSP_CODE",
1704 .expectIntExitResult = 1
1705 });
1706
1707 runScript({
1708 .code = R"NKSP_CODE(
1709 on init
1710 exit(139 - 74)
1711 end on
1712 )NKSP_CODE",
1713 .expectIntExitResult = 65
1714 });
1715
1716 runScript({
1717 .code = R"NKSP_CODE(
1718 on init
1719 exit(3 - 9)
1720 end on
1721 )NKSP_CODE",
1722 .expectIntExitResult = -6
1723 });
1724
1725 runScript({
1726 .code = R"NKSP_CODE(
1727 on init
1728 exit(-3 - 18)
1729 end on
1730 )NKSP_CODE",
1731 .expectIntExitResult = -21
1732 });
1733
1734 // real number tests ...
1735
1736 runScript({
1737 .code = R"NKSP_CODE(
1738 on init
1739 exit(4.0 - 0.2)
1740 end on
1741 )NKSP_CODE",
1742 .expectRealExitResult = 3.8
1743 });
1744
1745 runScript({
1746 .code = R"NKSP_CODE(
1747 on init
1748 exit(3.1 - 9.65)
1749 end on
1750 )NKSP_CODE",
1751 .expectRealExitResult = -6.55
1752 });
1753
1754 runScript({
1755 .code = R"NKSP_CODE(
1756 on init
1757 exit(-3.0 - 18.1)
1758 end on
1759 )NKSP_CODE",
1760 .expectRealExitResult = -21.1
1761 });
1762
1763 // std unit tests ...
1764
1765 runScript({
1766 .code = R"NKSP_CODE(
1767 on init
1768 exit(1000ms - 145ms)
1769 end on
1770 )NKSP_CODE",
1771 .expectIntExitResult = 855,
1772 .expectExitResultUnitPrefix = { VM_MILLI },
1773 .expectExitResultUnit = VM_SECOND
1774 });
1775
1776 runScript({
1777 .code = R"NKSP_CODE(
1778 on init
1779 exit(1s - 145ms)
1780 end on
1781 )NKSP_CODE",
1782 .expectIntExitResult = 855,
1783 .expectExitResultUnitPrefix = { VM_MILLI },
1784 .expectExitResultUnit = VM_SECOND
1785 });
1786
1787 runScript({
1788 .code = R"NKSP_CODE(
1789 on init
1790 exit(1s - 145)
1791 end on
1792 )NKSP_CODE",
1793 .expectParseError = true // units must match for - operator
1794 });
1795
1796 runScript({
1797 .code = R"NKSP_CODE(
1798 on init
1799 exit(1 - 145s)
1800 end on
1801 )NKSP_CODE",
1802 .expectParseError = true // units must match for - operator
1803 });
1804
1805 runScript({
1806 .code = R"NKSP_CODE(
1807 on init
1808 exit(1ms - 145mB)
1809 end on
1810 )NKSP_CODE",
1811 .expectParseError = true // units must match for - operator
1812 });
1813
1814 runScript({
1815 .code = R"NKSP_CODE(
1816 on init
1817 exit(1.0ms - 0.1ms)
1818 end on
1819 )NKSP_CODE",
1820 .expectRealExitResult = 0.9,
1821 .expectExitResultUnitPrefix = { VM_MILLI },
1822 .expectExitResultUnit = VM_SECOND
1823 });
1824
1825 runScript({
1826 .code = R"NKSP_CODE(
1827 on init
1828 exit(1.1s - 106.0ms)
1829 end on
1830 )NKSP_CODE",
1831 .expectRealExitResult = 994.0,
1832 .expectExitResultUnitPrefix = { VM_MILLI },
1833 .expectExitResultUnit = VM_SECOND
1834 });
1835
1836 runScript({
1837 .code = R"NKSP_CODE(
1838 on init
1839 exit(1100.0ms - 0.106s)
1840 end on
1841 )NKSP_CODE",
1842 .expectRealExitResult = 994.0,
1843 .expectExitResultUnitPrefix = { VM_MILLI },
1844 .expectExitResultUnit = VM_SECOND
1845 });
1846
1847 runScript({
1848 .code = R"NKSP_CODE(
1849 on init
1850 exit(1.0s - 145.0)
1851 end on
1852 )NKSP_CODE",
1853 .expectParseError = true // units must match for - operator
1854 });
1855
1856 runScript({
1857 .code = R"NKSP_CODE(
1858 on init
1859 exit(1.0 - 145.0s)
1860 end on
1861 )NKSP_CODE",
1862 .expectParseError = true // units must match for - operator
1863 });
1864
1865 runScript({
1866 .code = R"NKSP_CODE(
1867 on init
1868 exit(1.0ms - 145.0mB)
1869 end on
1870 )NKSP_CODE",
1871 .expectParseError = true // units must match for - operator
1872 });
1873
1874 // 'final' ('!') operator tests ...
1875
1876 runScript({
1877 .code = R"NKSP_CODE(
1878 on init
1879 exit(!5 - !3)
1880 end on
1881 )NKSP_CODE",
1882 .expectIntExitResult = 2,
1883 .expectExitResultFinal = true
1884 });
1885
1886 runScript({
1887 .code = R"NKSP_CODE(
1888 on init
1889 exit(5 - 3)
1890 end on
1891 )NKSP_CODE",
1892 .expectIntExitResult = 2,
1893 .expectExitResultFinal = false
1894 });
1895
1896 runScript({
1897 .code = R"NKSP_CODE(
1898 on init
1899 exit(!5.9 - !3.3)
1900 end on
1901 )NKSP_CODE",
1902 .expectRealExitResult = 2.6,
1903 .expectExitResultFinal = true
1904 });
1905
1906 runScript({
1907 .code = R"NKSP_CODE(
1908 on init
1909 exit(5.9 - 3.3)
1910 end on
1911 )NKSP_CODE",
1912 .expectRealExitResult = 2.6,
1913 .expectExitResultFinal = false
1914 });
1915
1916 #if !SILENT_TEST
1917 std::cout << std::endl;
1918 #endif
1919 }
1920
1921 static void testModuloOperator() {
1922 #if !SILENT_TEST
1923 std::cout << "UNIT TEST: modulo (mod) operator\n";
1924 #endif
1925
1926 // integer tests ...
1927
1928 runScript({
1929 .code = R"NKSP_CODE(
1930 on init
1931 exit(10 mod 8)
1932 end on
1933 )NKSP_CODE",
1934 .expectIntExitResult = 2
1935 });
1936
1937 runScript({
1938 .code = R"NKSP_CODE(
1939 on init
1940 declare $a := 10
1941 declare $b := 8
1942 exit($a mod $b)
1943 end on
1944 )NKSP_CODE",
1945 .expectIntExitResult = 2
1946 });
1947
1948 // real number tests ...
1949 // (mod operator prohibits real numbers ATM)
1950
1951 runScript({
1952 .code = R"NKSP_CODE(
1953 on init
1954 exit(10.0 mod 8.0)
1955 end on
1956 )NKSP_CODE",
1957 .expectParseError = true // mod operator prohibits real numbers ATM
1958 });
1959
1960 runScript({
1961 .code = R"NKSP_CODE(
1962 on init
1963 exit(10 mod 8.0)
1964 end on
1965 )NKSP_CODE",
1966 .expectParseError = true // mod operator prohibits real numbers ATM
1967 });
1968
1969 runScript({
1970 .code = R"NKSP_CODE(
1971 on init
1972 exit(10.0 mod 8)
1973 end on
1974 )NKSP_CODE",
1975 .expectParseError = true // mod operator prohibits real numbers ATM
1976 });
1977
1978 runScript({
1979 .code = R"NKSP_CODE(
1980 on init
1981 declare ~a := 10.0
1982 declare ~b := 8.0
1983 exit(~a mod ~b)
1984 end on
1985 )NKSP_CODE",
1986 .expectParseError = true // mod operator prohibits real numbers ATM
1987 });
1988
1989 // std unit tests ...
1990
1991 runScript({
1992 .code = R"NKSP_CODE(
1993 on init
1994 exit(10s mod 8)
1995 end on
1996 )NKSP_CODE",
1997 .expectParseError = true // mod operator prohibits std units ATM
1998 });
1999
2000 runScript({
2001 .code = R"NKSP_CODE(
2002 on init
2003 exit(10 mod 8s)
2004 end on
2005 )NKSP_CODE",
2006 .expectParseError = true // mod operator prohibits std units ATM
2007 });
2008
2009 runScript({
2010 .code = R"NKSP_CODE(
2011 on init
2012 exit(10s mod 8s)
2013 end on
2014 )NKSP_CODE",
2015 .expectParseError = true // mod operator prohibits std units ATM
2016 });
2017
2018 // 'final' ('!') operator tests ...
2019
2020 runScript({
2021 .code = R"NKSP_CODE(
2022 on init
2023 exit(!10 mod !8)
2024 end on
2025 )NKSP_CODE",
2026 .expectIntExitResult = 2,
2027 .expectExitResultFinal = true
2028 });
2029
2030 runScript({
2031 .code = R"NKSP_CODE(
2032 on init
2033 exit(10 mod 8)
2034 end on
2035 )NKSP_CODE",
2036 .expectIntExitResult = 2,
2037 .expectExitResultFinal = false
2038 });
2039
2040 #if !SILENT_TEST
2041 std::cout << std::endl;
2042 #endif
2043 }
2044
2045 static void testMultiplyOperator() {
2046 #if !SILENT_TEST
2047 std::cout << "UNIT TEST: multiply (*) operator\n";
2048 #endif
2049
2050 // integer tests ...
2051
2052 runScript({
2053 .code = R"NKSP_CODE(
2054 on init
2055 exit(10 * 8)
2056 end on
2057 )NKSP_CODE",
2058 .expectIntExitResult = 80
2059 });
2060
2061 runScript({
2062 .code = R"NKSP_CODE(
2063 on init
2064 exit(-3 * -4)
2065 end on
2066 )NKSP_CODE",
2067 .expectIntExitResult = 12
2068 });
2069
2070 runScript({
2071 .code = R"NKSP_CODE(
2072 on init
2073 exit(-52 * 63)
2074 end on
2075 )NKSP_CODE",
2076 .expectIntExitResult = -3276
2077 });
2078
2079 runScript({
2080 .code = R"NKSP_CODE(
2081 on init
2082 exit(123 * -59)
2083 end on
2084 )NKSP_CODE",
2085 .expectIntExitResult = -7257
2086 });
2087
2088 // real number tests ...
2089
2090 runScript({
2091 .code = R"NKSP_CODE(
2092 on init
2093 exit(10.2 * 8.4)
2094 end on
2095 )NKSP_CODE",
2096 .expectRealExitResult = 85.68
2097 });
2098
2099 runScript({
2100 .code = R"NKSP_CODE(
2101 on init
2102 exit(10.0 * -3.33)
2103 end on
2104 )NKSP_CODE",
2105 .expectRealExitResult = -33.3
2106 });
2107
2108 runScript({
2109 .code = R"NKSP_CODE(
2110 on init
2111 exit(-3.33 * 10.0)
2112 end on
2113 )NKSP_CODE",
2114 .expectRealExitResult = -33.3
2115 });
2116
2117 runScript({
2118 .code = R"NKSP_CODE(
2119 on init
2120 exit(-3.33 * -10.0)
2121 end on
2122 )NKSP_CODE",
2123 .expectRealExitResult = 33.3
2124 });
2125
2126 // mixed type tests ...
2127 // (mixed int * real forbidden ATM)
2128
2129 runScript({
2130 .code = R"NKSP_CODE(
2131 on init
2132 exit(2 * 3.0)
2133 end on
2134 )NKSP_CODE",
2135 .expectParseError = true // mixed int * real forbidden ATM
2136 });
2137
2138 runScript({
2139 .code = R"NKSP_CODE(
2140 on init
2141 exit(2.0 * 3)
2142 end on
2143 )NKSP_CODE",
2144 .expectParseError = true // mixed int * real forbidden ATM
2145 });
2146
2147 // std unit tests ...
2148
2149 runScript({
2150 .code = R"NKSP_CODE(
2151 on init
2152 exit(10ms * 8)
2153 end on
2154 )NKSP_CODE",
2155 .expectIntExitResult = 80,
2156 .expectExitResultUnitPrefix = { VM_MILLI },
2157 .expectExitResultUnit = VM_SECOND
2158 });
2159
2160 runScript({
2161 .code = R"NKSP_CODE(
2162 on init
2163 exit(10 * 8ms)
2164 end on
2165 )NKSP_CODE",
2166 .expectIntExitResult = 80,
2167 .expectExitResultUnitPrefix = { VM_MILLI },
2168 .expectExitResultUnit = VM_SECOND
2169 });
2170
2171 runScript({
2172 .code = R"NKSP_CODE(
2173 on init
2174 exit(10s * 8s)
2175 end on
2176 )NKSP_CODE",
2177 .expectParseError = true // units on both sides not allowed for * ATM
2178 });
2179
2180 runScript({
2181 .code = R"NKSP_CODE(
2182 on init
2183 exit(10cs * 8d)
2184 end on
2185 )NKSP_CODE",
2186 .expectIntExitResult = 80,
2187 .expectExitResultUnitPrefix = { VM_MILLI },
2188 .expectExitResultUnit = VM_SECOND
2189 });
2190
2191 runScript({
2192 .code = R"NKSP_CODE(
2193 on init
2194 exit(10m * 8ms)
2195 end on
2196 )NKSP_CODE",
2197 .expectIntExitResult = 80,
2198 .expectExitResultUnitPrefix = { VM_MICRO },
2199 .expectExitResultUnit = VM_SECOND
2200 });
2201
2202 runScript({
2203 .code = R"NKSP_CODE(
2204 on init
2205 exit(10ms * 8k)
2206 end on
2207 )NKSP_CODE",
2208 .expectIntExitResult = 80,
2209 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
2210 .expectExitResultUnit = VM_SECOND
2211 });
2212
2213 runScript({
2214 .code = R"NKSP_CODE(
2215 on init
2216 exit(10.1ms * 8.0)
2217 end on
2218 )NKSP_CODE",
2219 .expectRealExitResult = 80.8,
2220 .expectExitResultUnitPrefix = { VM_MILLI },
2221 .expectExitResultUnit = VM_SECOND
2222 });
2223
2224 runScript({
2225 .code = R"NKSP_CODE(
2226 on init
2227 exit(10.1 * 8.0ms)
2228 end on
2229 )NKSP_CODE",
2230 .expectRealExitResult = 80.8,
2231 .expectExitResultUnitPrefix = { VM_MILLI },
2232 .expectExitResultUnit = VM_SECOND
2233 });
2234
2235 runScript({
2236 .code = R"NKSP_CODE(
2237 on init
2238 exit(10.0s * 8.0s)
2239 end on
2240 )NKSP_CODE",
2241 .expectParseError = true // units on both sides not allowed for * ATM
2242 });
2243
2244 runScript({
2245 .code = R"NKSP_CODE(
2246 on init
2247 exit(10.1ds * 8.0c)
2248 end on
2249 )NKSP_CODE",
2250 .expectRealExitResult = 80.8,
2251 .expectExitResultUnitPrefix = { VM_MILLI },
2252 .expectExitResultUnit = VM_SECOND
2253 });
2254
2255 runScript({
2256 .code = R"NKSP_CODE(
2257 on init
2258 exit(10.1m * 8.0ms)
2259 end on
2260 )NKSP_CODE",
2261 .expectRealExitResult = 80.8,
2262 .expectExitResultUnitPrefix = { VM_MICRO },
2263 .expectExitResultUnit = VM_SECOND
2264 });
2265
2266 runScript({
2267 .code = R"NKSP_CODE(
2268 on init
2269 exit(10.1m * 8.0ks)
2270 end on
2271 )NKSP_CODE",
2272 .expectRealExitResult = 80.8,
2273 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
2274 .expectExitResultUnit = VM_SECOND
2275 });
2276
2277 runScript({
2278 .code = R"NKSP_CODE(
2279 on init
2280 declare ~foo := 1.0 { neutral }
2281 declare $bar := 7000ms
2282 exit(~foo * real($bar))
2283 end on
2284 )NKSP_CODE",
2285 .expectRealExitResult = 7000.0,
2286 .expectExitResultUnitPrefix = { VM_MILLI },
2287 .expectExitResultUnit = VM_SECOND
2288 });
2289
2290 runScript({
2291 .code = R"NKSP_CODE(
2292 on init
2293 declare $foo := 1 { neutral }
2294 declare $bar := 7000ms
2295 exit(real($foo) * real($bar))
2296 end on
2297 )NKSP_CODE",
2298 .expectRealExitResult = 7000.0,
2299 .expectExitResultUnitPrefix = { VM_MILLI },
2300 .expectExitResultUnit = VM_SECOND
2301 });
2302
2303 // 'final' ('!') operator tests ...
2304
2305 runScript({
2306 .code = R"NKSP_CODE(
2307 on init
2308 exit(!10 * !8)
2309 end on
2310 )NKSP_CODE",
2311 .expectIntExitResult = 80,
2312 .expectExitResultFinal = true
2313 });
2314
2315 runScript({
2316 .code = R"NKSP_CODE(
2317 on init
2318 exit(10 * 8)
2319 end on
2320 )NKSP_CODE",
2321 .expectIntExitResult = 80,
2322 .expectExitResultFinal = false
2323 });
2324
2325 runScript({
2326 .code = R"NKSP_CODE(
2327 on init
2328 exit(!10 * 8)
2329 end on
2330 )NKSP_CODE",
2331 .expectIntExitResult = 80,
2332 .expectExitResultFinal = true,
2333 .expectParseWarning = true // since final only on one side, result will be final though
2334 });
2335
2336 runScript({
2337 .code = R"NKSP_CODE(
2338 on init
2339 exit(10 * !8)
2340 end on
2341 )NKSP_CODE",
2342 .expectIntExitResult = 80,
2343 .expectExitResultFinal = true,
2344 .expectParseWarning = true // since final only on one side, result will be final though
2345 });
2346
2347 runScript({
2348 .code = R"NKSP_CODE(
2349 on init
2350 exit(!10.1 * !8.0)
2351 end on
2352 )NKSP_CODE",
2353 .expectRealExitResult = 80.8,
2354 .expectExitResultFinal = true
2355 });
2356
2357 runScript({
2358 .code = R"NKSP_CODE(
2359 on init
2360 exit(10.1 * 8.0)
2361 end on
2362 )NKSP_CODE",
2363 .expectRealExitResult = 80.8,
2364 .expectExitResultFinal = false
2365 });
2366
2367 runScript({
2368 .code = R"NKSP_CODE(
2369 on init
2370 exit(!10.1 * 8.0)
2371 end on
2372 )NKSP_CODE",
2373 .expectRealExitResult = 80.8,
2374 .expectExitResultFinal = true,
2375 .expectParseWarning = true // since final only on one side, result will be final though
2376 });
2377
2378 runScript({
2379 .code = R"NKSP_CODE(
2380 on init
2381 exit(10.1 * !8.0)
2382 end on
2383 )NKSP_CODE",
2384 .expectRealExitResult = 80.8,
2385 .expectExitResultFinal = true,
2386 .expectParseWarning = true // since final only on one side, result will be final though
2387 });
2388
2389 #if !SILENT_TEST
2390 std::cout << std::endl;
2391 #endif
2392 }
2393
2394 static void testDivideOperator() {
2395 #if !SILENT_TEST
2396 std::cout << "UNIT TEST: divide (/) operator\n";
2397 #endif
2398
2399 // integer tests ...
2400
2401 runScript({
2402 .code = R"NKSP_CODE(
2403 on init
2404 exit(9 / 3)
2405 end on
2406 )NKSP_CODE",
2407 .expectIntExitResult = 3
2408 });
2409
2410 runScript({
2411 .code = R"NKSP_CODE(
2412 on init
2413 exit(-27 / 3)
2414 end on
2415 )NKSP_CODE",
2416 .expectIntExitResult = -9
2417 });
2418
2419 runScript({
2420 .code = R"NKSP_CODE(
2421 on init
2422 exit(35 / -5)
2423 end on
2424 )NKSP_CODE",
2425 .expectIntExitResult = -7
2426 });
2427
2428 runScript({
2429 .code = R"NKSP_CODE(
2430 on init
2431 exit(39 / -5)
2432 end on
2433 )NKSP_CODE",
2434 .expectIntExitResult = -7
2435 });
2436
2437 // real number tests ...
2438
2439 runScript({
2440 .code = R"NKSP_CODE(
2441 on init
2442 exit(9.0 / 10.0)
2443 end on
2444 )NKSP_CODE",
2445 .expectRealExitResult = 0.9
2446 });
2447
2448 runScript({
2449 .code = R"NKSP_CODE(
2450 on init
2451 exit(-9.0 / 10.0)
2452 end on
2453 )NKSP_CODE",
2454 .expectRealExitResult = -0.9
2455 });
2456
2457 runScript({
2458 .code = R"NKSP_CODE(
2459 on init
2460 exit(9.0 / -10.0)
2461 end on
2462 )NKSP_CODE",
2463 .expectRealExitResult = -0.9
2464 });
2465
2466 runScript({
2467 .code = R"NKSP_CODE(
2468 on init
2469 exit(-9.0 / -10.0)
2470 end on
2471 )NKSP_CODE",
2472 .expectRealExitResult = 0.9
2473 });
2474
2475 // mixed type tests ...
2476 // (mixed int / real forbidden ATM)
2477
2478 runScript({
2479 .code = R"NKSP_CODE(
2480 on init
2481 exit(9 / 10.0)
2482 end on
2483 )NKSP_CODE",
2484 .expectParseError = true // mixed int / real forbidden ATM
2485 });
2486
2487 runScript({
2488 .code = R"NKSP_CODE(
2489 on init
2490 exit(9.0 / 10)
2491 end on
2492 )NKSP_CODE",
2493 .expectParseError = true // mixed int / real forbidden ATM
2494 });
2495
2496 // std unit tests ...
2497
2498 runScript({
2499 .code = R"NKSP_CODE(
2500 on init
2501 exit(-27us / 3)
2502 end on
2503 )NKSP_CODE",
2504 .expectIntExitResult = -9,
2505 .expectExitResultUnitPrefix = { VM_MICRO },
2506 .expectExitResultUnit = VM_SECOND
2507 });
2508
2509 runScript({
2510 .code = R"NKSP_CODE(
2511 on init
2512 exit(-27mdB / 3mdB)
2513 end on
2514 )NKSP_CODE",
2515 .expectIntExitResult = -9,
2516 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
2517 .expectExitResultUnit = VM_NO_UNIT
2518 });
2519
2520 runScript({
2521 .code = R"NKSP_CODE(
2522 on init
2523 exit(-27s / 3m)
2524 end on
2525 )NKSP_CODE",
2526 .expectIntExitResult = -9,
2527 .expectExitResultUnitPrefix = { VM_KILO },
2528 .expectExitResultUnit = VM_SECOND
2529 });
2530
2531 runScript({
2532 .code = R"NKSP_CODE(
2533 on init
2534 exit(-27us / 3m)
2535 end on
2536 )NKSP_CODE",
2537 .expectIntExitResult = -9,
2538 .expectExitResultUnitPrefix = { VM_MILLI },
2539 .expectExitResultUnit = VM_SECOND
2540 });
2541
2542 runScript({
2543 .code = R"NKSP_CODE(
2544 on init
2545 exit(-27 / 3s)
2546 end on
2547 )NKSP_CODE",
2548 .expectParseError = true // illegal unit type arrangement for divisions
2549 });
2550
2551 runScript({
2552 .code = R"NKSP_CODE(
2553 on init
2554 exit(-27s / 3Hz)
2555 end on
2556 )NKSP_CODE",
2557 .expectParseError = true // unit types are not matching
2558 });
2559
2560 runScript({
2561 .code = R"NKSP_CODE(
2562 on init
2563 declare $foo := 1000000
2564 declare $bar := 7000ms
2565 exit(real($foo) / 1000000.0 * real($bar))
2566 end on
2567 )NKSP_CODE",
2568 .expectRealExitResult = 7000.0,
2569 .expectExitResultUnitPrefix = { VM_MILLI },
2570 .expectExitResultUnit = VM_SECOND
2571 });
2572
2573 // 'final' ('!') operator tests ...
2574
2575 runScript({
2576 .code = R"NKSP_CODE(
2577 on init
2578 exit(!-27 / !3)
2579 end on
2580 )NKSP_CODE",
2581 .expectIntExitResult = -9,
2582 .expectExitResultFinal = true
2583 });
2584
2585 runScript({
2586 .code = R"NKSP_CODE(
2587 on init
2588 exit(-27 / 3)
2589 end on
2590 )NKSP_CODE",
2591 .expectIntExitResult = -9,
2592 .expectExitResultFinal = false
2593 });
2594
2595 runScript({
2596 .code = R"NKSP_CODE(
2597 on init
2598 exit(!-27 / 3)
2599 end on
2600 )NKSP_CODE",
2601 .expectIntExitResult = -9,
2602 .expectExitResultFinal = true,
2603 .expectParseWarning = true // final only on one side, result will be final though
2604 });
2605
2606 runScript({
2607 .code = R"NKSP_CODE(
2608 on init
2609 exit(-27 / !3)
2610 end on
2611 )NKSP_CODE",
2612 .expectIntExitResult = -9,
2613 .expectExitResultFinal = true,
2614 .expectParseWarning = true // final only on one side, result will be final though
2615 });
2616
2617 #if !SILENT_TEST
2618 std::cout << std::endl;
2619 #endif
2620 }
2621
2622 static void testSmallerThanOperator() {
2623 #if !SILENT_TEST
2624 std::cout << "UNIT TEST: smaller than (<) operator\n";
2625 #endif
2626
2627 // integer tests ...
2628
2629 runScript({
2630 .code = R"NKSP_CODE(
2631 on init
2632 exit(3 < 4)
2633 end on
2634 )NKSP_CODE",
2635 .expectBoolExitResult = true
2636 });
2637
2638 runScript({
2639 .code = R"NKSP_CODE(
2640 on init
2641 exit(4 < 3)
2642 end on
2643 )NKSP_CODE",
2644 .expectBoolExitResult = false
2645 });
2646
2647 runScript({
2648 .code = R"NKSP_CODE(
2649 on init
2650 exit(-4 < 3)
2651 end on
2652 )NKSP_CODE",
2653 .expectBoolExitResult = true
2654 });
2655
2656 runScript({
2657 .code = R"NKSP_CODE(
2658 on init
2659 exit(3 < -4)
2660 end on
2661 )NKSP_CODE",
2662 .expectBoolExitResult = false
2663 });
2664
2665 runScript({
2666 .code = R"NKSP_CODE(
2667 on init
2668 exit(123 < -45)
2669 end on
2670 )NKSP_CODE",
2671 .expectBoolExitResult = false
2672 });
2673
2674 runScript({
2675 .code = R"NKSP_CODE(
2676 on init
2677 exit(-45 < 123)
2678 end on
2679 )NKSP_CODE",
2680 .expectBoolExitResult = true
2681 });
2682
2683 // real number tests ...
2684
2685 runScript({
2686 .code = R"NKSP_CODE(
2687 on init
2688 exit(3.0 < 4.0)
2689 end on
2690 )NKSP_CODE",
2691 .expectBoolExitResult = true
2692 });
2693
2694 runScript({
2695 .code = R"NKSP_CODE(
2696 on init
2697 exit(4.0 < 3.0)
2698 end on
2699 )NKSP_CODE",
2700 .expectBoolExitResult = false
2701 });
2702
2703 runScript({
2704 .code = R"NKSP_CODE(
2705 on init
2706 exit(1.2 < 1.23)
2707 end on
2708 )NKSP_CODE",
2709 .expectBoolExitResult = true
2710 });
2711
2712 runScript({
2713 .code = R"NKSP_CODE(
2714 on init
2715 exit(1.23 < 1.2)
2716 end on
2717 )NKSP_CODE",
2718 .expectBoolExitResult = false
2719 });
2720
2721 runScript({
2722 .code = R"NKSP_CODE(
2723 on init
2724 exit(-4.0 < 3.0)
2725 end on
2726 )NKSP_CODE",
2727 .expectBoolExitResult = true
2728 });
2729
2730 runScript({
2731 .code = R"NKSP_CODE(
2732 on init
2733 exit(3.0 < -4.0)
2734 end on
2735 )NKSP_CODE",
2736 .expectBoolExitResult = false
2737 });
2738
2739 runScript({
2740 .code = R"NKSP_CODE(
2741 on init
2742 exit(123.0 < -45.0)
2743 end on
2744 )NKSP_CODE",
2745 .expectBoolExitResult = false
2746 });
2747
2748 runScript({
2749 .code = R"NKSP_CODE(
2750 on init
2751 exit(-45.0 < 123.0)
2752 end on
2753 )NKSP_CODE",
2754 .expectBoolExitResult = true
2755 });
2756
2757 // mixed type tests ...
2758
2759 runScript({
2760 .code = R"NKSP_CODE(
2761 on init
2762 exit(9 < 9.1)
2763 end on
2764 )NKSP_CODE",
2765 .expectBoolExitResult = true
2766 });
2767
2768 runScript({
2769 .code = R"NKSP_CODE(
2770 on init
2771 exit(9.1 < 9)
2772 end on
2773 )NKSP_CODE",
2774 .expectBoolExitResult = false
2775 });
2776
2777 // std unit tests ...
2778
2779 runScript({
2780 .code = R"NKSP_CODE(
2781 on init
2782 exit(13ms < 14ms)
2783 end on
2784 )NKSP_CODE",
2785 .expectBoolExitResult = true
2786 });
2787
2788 runScript({
2789 .code = R"NKSP_CODE(
2790 on init
2791 exit(14ms < 13ms)
2792 end on
2793 )NKSP_CODE",
2794 .expectBoolExitResult = false
2795 });
2796
2797 runScript({
2798 .code = R"NKSP_CODE(
2799 on init
2800 exit(1s < 990ms)
2801 end on
2802 )NKSP_CODE",
2803 .expectBoolExitResult = false
2804 });
2805
2806 runScript({
2807 .code = R"NKSP_CODE(
2808 on init
2809 exit(990ms < 1s)
2810 end on
2811 )NKSP_CODE",
2812 .expectBoolExitResult = true
2813 });
2814
2815 runScript({
2816 .code = R"NKSP_CODE(
2817 on init
2818 exit(1000ms < 1s)
2819 end on
2820 )NKSP_CODE",
2821 .expectBoolExitResult = false
2822 });
2823
2824 runScript({
2825 .code = R"NKSP_CODE(
2826 on init
2827 exit(1s < 1000ms)
2828 end on
2829 )NKSP_CODE",
2830 .expectBoolExitResult = false
2831 });
2832
2833 runScript({
2834 .code = R"NKSP_CODE(
2835 on init
2836 exit(1s < 1)
2837 end on
2838 )NKSP_CODE",
2839 .expectParseError = true // units on both sides must match
2840 });
2841
2842 runScript({
2843 .code = R"NKSP_CODE(
2844 on init
2845 exit(1 < 1s)
2846 end on
2847 )NKSP_CODE",
2848 .expectParseError = true // units on both sides must match
2849 });
2850
2851 runScript({
2852 .code = R"NKSP_CODE(
2853 on init
2854 exit(1Hz < 1B)
2855 end on
2856 )NKSP_CODE",
2857 .expectParseError = true // units on both sides must match
2858 });
2859
2860 runScript({
2861 .code = R"NKSP_CODE(
2862 on init
2863 exit(13.0ms < 13.1ms)
2864 end on
2865 )NKSP_CODE",
2866 .expectBoolExitResult = true
2867 });
2868
2869 runScript({
2870 .code = R"NKSP_CODE(
2871 on init
2872 exit(13.1ms < 13.0ms)
2873 end on
2874 )NKSP_CODE",
2875 .expectBoolExitResult = false
2876 });
2877
2878 runScript({
2879 .code = R"NKSP_CODE(
2880 on init
2881 exit(0.9s < 600.0ms)
2882 end on
2883 )NKSP_CODE",
2884 .expectBoolExitResult = false
2885 });
2886
2887 runScript({
2888 .code = R"NKSP_CODE(
2889 on init
2890 exit(600.0ms < 0.9s)
2891 end on
2892 )NKSP_CODE",
2893 .expectBoolExitResult = true
2894 });
2895
2896 runScript({
2897 .code = R"NKSP_CODE(
2898 on init
2899 exit(5.1kHz < 5100.0Hz)
2900 end on
2901 )NKSP_CODE",
2902 .expectBoolExitResult = false
2903 });
2904
2905 runScript({
2906 .code = R"NKSP_CODE(
2907 on init
2908 exit(5100.0Hz < 5.1kHz)
2909 end on
2910 )NKSP_CODE",
2911 .expectBoolExitResult = false
2912 });
2913
2914 runScript({
2915 .code = R"NKSP_CODE(
2916 on init
2917 exit(1.0Hz < 1.1)
2918 end on
2919 )NKSP_CODE",
2920 .expectParseError = true // units on both sides must match
2921 });
2922
2923 runScript({
2924 .code = R"NKSP_CODE(
2925 on init
2926 exit(1.2 < 1.34mdB)
2927 end on
2928 )NKSP_CODE",
2929 .expectParseError = true // units on both sides must match
2930 });
2931
2932 runScript({
2933 .code = R"NKSP_CODE(
2934 on init
2935 exit(9.23us < 3.14kHz)
2936 end on
2937 )NKSP_CODE",
2938 .expectParseError = true // units on both sides must match
2939 });
2940
2941 // 'final' ('!') operator tests ...
2942 // (should always yield in false for relation operators)
2943
2944 runScript({
2945 .code = R"NKSP_CODE(
2946 on init
2947 exit(!-4 < !3)
2948 end on
2949 )NKSP_CODE",
2950 .expectBoolExitResult = true,
2951 .expectExitResultFinal = false
2952 });
2953
2954 runScript({
2955 .code = R"NKSP_CODE(
2956 on init
2957 exit(-4 < 3)
2958 end on
2959 )NKSP_CODE",
2960 .expectBoolExitResult = true,
2961 .expectExitResultFinal = false
2962 });
2963
2964 #if !SILENT_TEST
2965 std::cout << std::endl;
2966 #endif
2967 }
2968
2969 static void testGreaterThanOperator() {
2970 #if !SILENT_TEST
2971 std::cout << "UNIT TEST: greater than (>) operator\n";
2972 #endif
2973
2974 // integer tests ...
2975
2976 runScript({
2977 .code = R"NKSP_CODE(
2978 on init
2979 exit(3 > 4)
2980 end on
2981 )NKSP_CODE",
2982 .expectBoolExitResult = false
2983 });
2984
2985 runScript({
2986 .code = R"NKSP_CODE(
2987 on init
2988 exit(4 > 3)
2989 end on
2990 )NKSP_CODE",
2991 .expectBoolExitResult = true
2992 });
2993
2994 runScript({
2995 .code = R"NKSP_CODE(
2996 on init
2997 exit(-4 > 3)
2998 end on
2999 )NKSP_CODE",
3000 .expectBoolExitResult = false
3001 });
3002
3003 runScript({
3004 .code = R"NKSP_CODE(
3005 on init
3006 exit(3 > -4)
3007 end on
3008 )NKSP_CODE",
3009 .expectBoolExitResult = true
3010 });
3011
3012 runScript({
3013 .code = R"NKSP_CODE(
3014 on init
3015 exit(123 > -45)
3016 end on
3017 )NKSP_CODE",
3018 .expectBoolExitResult = true
3019 });
3020
3021 runScript({
3022 .code = R"NKSP_CODE(
3023 on init
3024 exit(-45 > 123)
3025 end on
3026 )NKSP_CODE",
3027 .expectBoolExitResult = false
3028 });
3029
3030 // real number tests ...
3031
3032 runScript({
3033 .code = R"NKSP_CODE(
3034 on init
3035 exit(3.0 > 4.0)
3036 end on
3037 )NKSP_CODE",
3038 .expectBoolExitResult = false
3039 });
3040
3041 runScript({
3042 .code = R"NKSP_CODE(
3043 on init
3044 exit(4.0 > 3.0)
3045 end on
3046 )NKSP_CODE",
3047 .expectBoolExitResult = true
3048 });
3049
3050 runScript({
3051 .code = R"NKSP_CODE(
3052 on init
3053 exit(1.2 > 1.23)
3054 end on
3055 )NKSP_CODE",
3056 .expectBoolExitResult = false
3057 });
3058
3059 runScript({
3060 .code = R"NKSP_CODE(
3061 on init
3062 exit(1.23 > 1.2)
3063 end on
3064 )NKSP_CODE",
3065 .expectBoolExitResult = true
3066 });
3067
3068 runScript({
3069 .code = R"NKSP_CODE(
3070 on init
3071 exit(-4.0 > 3.0)
3072 end on
3073 )NKSP_CODE",
3074 .expectBoolExitResult = false
3075 });
3076
3077 runScript({
3078 .code = R"NKSP_CODE(
3079 on init
3080 exit(3.0 > -4.0)
3081 end on
3082 )NKSP_CODE",
3083 .expectBoolExitResult = true
3084 });
3085
3086 runScript({
3087 .code = R"NKSP_CODE(
3088 on init
3089 exit(123.0 > -45.0)
3090 end on
3091 )NKSP_CODE",
3092 .expectBoolExitResult = true
3093 });
3094
3095 runScript({
3096 .code = R"NKSP_CODE(
3097 on init
3098 exit(-45.0 > 123.0)
3099 end on
3100 )NKSP_CODE",
3101 .expectBoolExitResult = false
3102 });
3103
3104 // mixed type tests ...
3105
3106 runScript({
3107 .code = R"NKSP_CODE(
3108 on init
3109 exit(9 > 9.1)
3110 end on
3111 )NKSP_CODE",
3112 .expectBoolExitResult = false
3113 });
3114
3115 runScript({
3116 .code = R"NKSP_CODE(
3117 on init
3118 exit(9.1 > 9)
3119 end on
3120 )NKSP_CODE",
3121 .expectBoolExitResult = true
3122 });
3123
3124 // std unit tests ...
3125
3126 runScript({
3127 .code = R"NKSP_CODE(
3128 on init
3129 exit(13ms > 14ms)
3130 end on
3131 )NKSP_CODE",
3132 .expectBoolExitResult = false
3133 });
3134
3135 runScript({
3136 .code = R"NKSP_CODE(
3137 on init
3138 exit(14ms > 13ms)
3139 end on
3140 )NKSP_CODE",
3141 .expectBoolExitResult = true
3142 });
3143
3144 runScript({
3145 .code = R"NKSP_CODE(
3146 on init
3147 exit(1s > 990ms)
3148 end on
3149 )NKSP_CODE",
3150 .expectBoolExitResult = true
3151 });
3152
3153 runScript({
3154 .code = R"NKSP_CODE(
3155 on init
3156 exit(990ms > 1s)
3157 end on
3158 )NKSP_CODE",
3159 .expectBoolExitResult = false
3160 });
3161
3162 runScript({
3163 .code = R"NKSP_CODE(
3164 on init
3165 exit(1000ms > 1s)
3166 end on
3167 )NKSP_CODE",
3168 .expectBoolExitResult = false
3169 });
3170
3171 runScript({
3172 .code = R"NKSP_CODE(
3173 on init
3174 exit(1s > 1000ms)
3175 end on
3176 )NKSP_CODE",
3177 .expectBoolExitResult = false
3178 });
3179
3180 runScript({
3181 .code = R"NKSP_CODE(
3182 on init
3183 exit(1s > 1)
3184 end on
3185 )NKSP_CODE",
3186 .expectParseError = true // units on both sides must match
3187 });
3188
3189 runScript({
3190 .code = R"NKSP_CODE(
3191 on init
3192 exit(1 > 1s)
3193 end on
3194 )NKSP_CODE",
3195 .expectParseError = true // units on both sides must match
3196 });
3197
3198 runScript({
3199 .code = R"NKSP_CODE(
3200 on init
3201 exit(1Hz > 1B)
3202 end on
3203 )NKSP_CODE",
3204 .expectParseError = true // units on both sides must match
3205 });
3206
3207 runScript({
3208 .code = R"NKSP_CODE(
3209 on init
3210 exit(13.0ms > 13.1ms)
3211 end on
3212 )NKSP_CODE",
3213 .expectBoolExitResult = false
3214 });
3215
3216 runScript({
3217 .code = R"NKSP_CODE(
3218 on init
3219 exit(13.1ms > 13.0ms)
3220 end on
3221 )NKSP_CODE",
3222 .expectBoolExitResult = true
3223 });
3224
3225 runScript({
3226 .code = R"NKSP_CODE(
3227 on init
3228 exit(0.9s > 600.0ms)
3229 end on
3230 )NKSP_CODE",
3231 .expectBoolExitResult = true
3232 });
3233
3234 runScript({
3235 .code = R"NKSP_CODE(
3236 on init
3237 exit(600.0ms > 0.9s)
3238 end on
3239 )NKSP_CODE",
3240 .expectBoolExitResult = false
3241 });
3242
3243 runScript({
3244 .code = R"NKSP_CODE(
3245 on init
3246 exit(5.1kHz > 5100.0Hz)
3247 end on
3248 )NKSP_CODE",
3249 .expectBoolExitResult = false
3250 });
3251
3252 runScript({
3253 .code = R"NKSP_CODE(
3254 on init
3255 exit(5100.0Hz > 5.1kHz)
3256 end on
3257 )NKSP_CODE",
3258 .expectBoolExitResult = false
3259 });
3260
3261 runScript({
3262 .code = R"NKSP_CODE(
3263 on init
3264 exit(1.0Hz > 1.1)
3265 end on
3266 )NKSP_CODE",
3267 .expectParseError = true // units on both sides must match
3268 });
3269
3270 runScript({
3271 .code = R"NKSP_CODE(
3272 on init
3273 exit(1.2 > 1.34mdB)
3274 end on
3275 )NKSP_CODE",
3276 .expectParseError = true // units on both sides must match
3277 });
3278
3279 runScript({
3280 .code = R"NKSP_CODE(
3281 on init
3282 exit(9.23us > 3.14kHz)
3283 end on
3284 )NKSP_CODE",
3285 .expectParseError = true // units on both sides must match
3286 });
3287
3288 // 'final' ('!') operator tests ...
3289 // (should always yield in false for relation operators)
3290
3291 runScript({
3292 .code = R"NKSP_CODE(
3293 on init
3294 exit(!-4 > !3)
3295 end on
3296 )NKSP_CODE",
3297 .expectBoolExitResult = false,
3298 .expectExitResultFinal = false
3299 });
3300
3301 runScript({
3302 .code = R"NKSP_CODE(
3303 on init
3304 exit(-4 > 3)
3305 end on
3306 )NKSP_CODE",
3307 .expectBoolExitResult = false,
3308 .expectExitResultFinal = false
3309 });
3310
3311 #if !SILENT_TEST
3312 std::cout << std::endl;
3313 #endif
3314 }
3315
3316 static void testSmallerOrEqualOperator() {
3317 #if !SILENT_TEST
3318 std::cout << "UNIT TEST: smaller-or-equal (<=) operator\n";
3319 #endif
3320
3321 // integer tests ...
3322
3323 runScript({
3324 .code = R"NKSP_CODE(
3325 on init
3326 exit(3 <= 3)
3327 end on
3328 )NKSP_CODE",
3329 .expectBoolExitResult = true
3330 });
3331
3332 runScript({
3333 .code = R"NKSP_CODE(
3334 on init
3335 exit(4 <= 4)
3336 end on
3337 )NKSP_CODE",
3338 .expectBoolExitResult = true
3339 });
3340
3341 runScript({
3342 .code = R"NKSP_CODE(
3343 on init
3344 exit(-23 <= -23)
3345 end on
3346 )NKSP_CODE",
3347 .expectBoolExitResult = true
3348 });
3349
3350 runScript({
3351 .code = R"NKSP_CODE(
3352 on init
3353 exit(23 <= -23)
3354 end on
3355 )NKSP_CODE",
3356 .expectBoolExitResult = false
3357 });
3358
3359 runScript({
3360 .code = R"NKSP_CODE(
3361 on init
3362 exit(3 <= 4)
3363 end on
3364 )NKSP_CODE",
3365 .expectBoolExitResult = true
3366 });
3367
3368 runScript({
3369 .code = R"NKSP_CODE(
3370 on init
3371 exit(4 <= 3)
3372 end on
3373 )NKSP_CODE",
3374 .expectBoolExitResult = false
3375 });
3376
3377 runScript({
3378 .code = R"NKSP_CODE(
3379 on init
3380 exit(-4 <= 3)
3381 end on
3382 )NKSP_CODE",
3383 .expectBoolExitResult = true
3384 });
3385
3386 runScript({
3387 .code = R"NKSP_CODE(
3388 on init
3389 exit(3 <= -4)
3390 end on
3391 )NKSP_CODE",
3392 .expectBoolExitResult = false
3393 });
3394
3395 runScript({
3396 .code = R"NKSP_CODE(
3397 on init
3398 exit(123 <= -45)
3399 end on
3400 )NKSP_CODE",
3401 .expectBoolExitResult = false
3402 });
3403
3404 runScript({
3405 .code = R"NKSP_CODE(
3406 on init
3407 exit(-45 <= 123)
3408 end on
3409 )NKSP_CODE",
3410 .expectBoolExitResult = true
3411 });
3412
3413 // real number tests ...
3414
3415 runScript({
3416 .code = R"NKSP_CODE(
3417 on init
3418 exit(3.0 <= 3.0)
3419 end on
3420 )NKSP_CODE",
3421 .expectBoolExitResult = true
3422 });
3423
3424 runScript({
3425 .code = R"NKSP_CODE(
3426 on init
3427 exit(4.33 <= 4.33)
3428 end on
3429 )NKSP_CODE",
3430 .expectBoolExitResult = true
3431 });
3432
3433 runScript({
3434 .code = R"NKSP_CODE(
3435 on init
3436 exit(-23.1 <= -23.1)
3437 end on
3438 )NKSP_CODE",
3439 .expectBoolExitResult = true
3440 });
3441
3442 runScript({
3443 .code = R"NKSP_CODE(
3444 on init
3445 exit(23.3 <= -23.3)
3446 end on
3447 )NKSP_CODE",
3448 .expectBoolExitResult = false
3449 });
3450
3451 runScript({
3452 .code = R"NKSP_CODE(
3453 on init
3454 exit(3.0 <= 4.0)
3455 end on
3456 )NKSP_CODE",
3457 .expectBoolExitResult = true
3458 });
3459
3460 runScript({
3461 .code = R"NKSP_CODE(
3462 on init
3463 exit(4.0 <= 3.0)
3464 end on
3465 )NKSP_CODE",
3466 .expectBoolExitResult = false
3467 });
3468
3469 runScript({
3470 .code = R"NKSP_CODE(
3471 on init
3472 exit(-4.0 <= 3.0)
3473 end on
3474 )NKSP_CODE",
3475 .expectBoolExitResult = true
3476 });
3477
3478 runScript({
3479 .code = R"NKSP_CODE(
3480 on init
3481 exit(3.0 <= -4.0)
3482 end on
3483 )NKSP_CODE",
3484 .expectBoolExitResult = false
3485 });
3486
3487 runScript({
3488 .code = R"NKSP_CODE(
3489 on init
3490 exit(123.0 <= -45.0)
3491 end on
3492 )NKSP_CODE",
3493 .expectBoolExitResult = false
3494 });
3495
3496 runScript({
3497 .code = R"NKSP_CODE(
3498 on init
3499 exit(-45.0 <= 123.0)
3500 end on
3501 )NKSP_CODE",
3502 .expectBoolExitResult = true
3503 });
3504
3505 // mixed type tests ...
3506
3507 runScript({
3508 .code = R"NKSP_CODE(
3509 on init
3510 exit(9 <= 9.1)
3511 end on
3512 )NKSP_CODE",
3513 .expectBoolExitResult = true
3514 });
3515
3516 runScript({
3517 .code = R"NKSP_CODE(
3518 on init
3519 exit(9.1 <= 9)
3520 end on
3521 )NKSP_CODE",
3522 .expectBoolExitResult = false
3523 });
3524
3525 runScript({
3526 .code = R"NKSP_CODE(
3527 on init
3528 exit(9 <= 9.0)
3529 end on
3530 )NKSP_CODE",
3531 .expectBoolExitResult = true
3532 });
3533
3534 runScript({
3535 .code = R"NKSP_CODE(
3536 on init
3537 exit(9.0 <= 9)
3538 end on
3539 )NKSP_CODE",
3540 .expectBoolExitResult = true
3541 });
3542
3543 // std unit tests ...
3544
3545 runScript({
3546 .code = R"NKSP_CODE(
3547 on init
3548 exit(13ms <= 14ms)
3549 end on
3550 )NKSP_CODE",
3551 .expectBoolExitResult = true
3552 });
3553
3554 runScript({
3555 .code = R"NKSP_CODE(
3556 on init
3557 exit(14ms <= 13ms)
3558 end on
3559 )NKSP_CODE",
3560 .expectBoolExitResult = false
3561 });
3562
3563 runScript({
3564 .code = R"NKSP_CODE(
3565 on init
3566 exit(1s <= 990ms)
3567 end on
3568 )NKSP_CODE",
3569 .expectBoolExitResult = false
3570 });
3571
3572 runScript({
3573 .code = R"NKSP_CODE(
3574 on init
3575 exit(990ms <= 1s)
3576 end on
3577 )NKSP_CODE",
3578 .expectBoolExitResult = true
3579 });
3580
3581 runScript({
3582 .code = R"NKSP_CODE(
3583 on init
3584 exit(1000ms <= 1s)
3585 end on
3586 )NKSP_CODE",
3587 .expectBoolExitResult = true
3588 });
3589
3590 runScript({
3591 .code = R"NKSP_CODE(
3592 on init
3593 exit(1s <= 1000ms)
3594 end on
3595 )NKSP_CODE",
3596 .expectBoolExitResult = true
3597 });
3598
3599 runScript({
3600 .code = R"NKSP_CODE(
3601 on init
3602 exit(1s <= 1)
3603 end on
3604 )NKSP_CODE",
3605 .expectParseError = true // units on both sides must match
3606 });
3607
3608 runScript({
3609 .code = R"NKSP_CODE(
3610 on init
3611 exit(1 <= 1s)
3612 end on
3613 )NKSP_CODE",
3614 .expectParseError = true // units on both sides must match
3615 });
3616
3617 runScript({
3618 .code = R"NKSP_CODE(
3619 on init
3620 exit(1Hz <= 1B)
3621 end on
3622 )NKSP_CODE",
3623 .expectParseError = true // units on both sides must match
3624 });
3625
3626 runScript({
3627 .code = R"NKSP_CODE(
3628 on init
3629 exit(13.0ms <= 13.1ms)
3630 end on
3631 )NKSP_CODE",
3632 .expectBoolExitResult = true
3633 });
3634
3635 runScript({
3636 .code = R"NKSP_CODE(
3637 on init
3638 exit(13.1ms <= 13.0ms)
3639 end on
3640 )NKSP_CODE",
3641 .expectBoolExitResult = false
3642 });
3643
3644 runScript({
3645 .code = R"NKSP_CODE(
3646 on init
3647 exit(0.9s <= 600.0ms)
3648 end on
3649 )NKSP_CODE",
3650 .expectBoolExitResult = false
3651 });
3652
3653 runScript({
3654 .code = R"NKSP_CODE(
3655 on init
3656 exit(600.0ms <= 0.9s)
3657 end on
3658 )NKSP_CODE",
3659 .expectBoolExitResult = true
3660 });
3661
3662 runScript({
3663 .code = R"NKSP_CODE(
3664 on init
3665 exit(5.1kHz <= 5100.0Hz)
3666 end on
3667 )NKSP_CODE",
3668 .expectBoolExitResult = true
3669 });
3670
3671 runScript({
3672 .code = R"NKSP_CODE(
3673 on init
3674 exit(5100.0Hz <= 5.1kHz)
3675 end on
3676 )NKSP_CODE",
3677 .expectBoolExitResult = true
3678 });
3679
3680 runScript({
3681 .code = R"NKSP_CODE(
3682 on init
3683 exit(1.0Hz <= 1.1)
3684 end on
3685 )NKSP_CODE",
3686 .expectParseError = true // units on both sides must match
3687 });
3688
3689 runScript({
3690 .code = R"NKSP_CODE(
3691 on init
3692 exit(1.2 <= 1.34mdB)
3693 end on
3694 )NKSP_CODE",
3695 .expectParseError = true // units on both sides must match
3696 });
3697
3698 runScript({
3699 .code = R"NKSP_CODE(
3700 on init
3701 exit(9.23us <= 3.14kHz)
3702 end on
3703 )NKSP_CODE",
3704 .expectParseError = true // units on both sides must match
3705 });
3706
3707 // 'final' ('!') operator tests ...
3708 // (should always yield in false for relation operators)
3709
3710 runScript({
3711 .code = R"NKSP_CODE(
3712 on init
3713 exit(!-4 <= !3)
3714 end on
3715 )NKSP_CODE",
3716 .expectBoolExitResult = true,
3717 .expectExitResultFinal = false
3718 });
3719
3720 runScript({
3721 .code = R"NKSP_CODE(
3722 on init
3723 exit(-4 <= 3)
3724 end on
3725 )NKSP_CODE",
3726 .expectBoolExitResult = true,
3727 .expectExitResultFinal = false
3728 });
3729
3730 #if !SILENT_TEST
3731 std::cout << std::endl;
3732 #endif
3733 }
3734
3735 static void testGreaterOrEqualOperator() {
3736 #if !SILENT_TEST
3737 std::cout << "UNIT TEST: greater-or-equal (>=) operator\n";
3738 #endif
3739
3740 // integer tests ...
3741
3742 runScript({
3743 .code = R"NKSP_CODE(
3744 on init
3745 exit(3 >= 3)
3746 end on
3747 )NKSP_CODE",
3748 .expectBoolExitResult = true
3749 });
3750
3751 runScript({
3752 .code = R"NKSP_CODE(
3753 on init
3754 exit(4 >= 4)
3755 end on
3756 )NKSP_CODE",
3757 .expectBoolExitResult = true
3758 });
3759
3760 runScript({
3761 .code = R"NKSP_CODE(
3762 on init
3763 exit(-23 >= -23)
3764 end on
3765 )NKSP_CODE",
3766 .expectBoolExitResult = true
3767 });
3768
3769 runScript({
3770 .code = R"NKSP_CODE(
3771 on init
3772 exit(23 >= -23)
3773 end on
3774 )NKSP_CODE",
3775 .expectBoolExitResult = true
3776 });
3777
3778 runScript({
3779 .code = R"NKSP_CODE(
3780 on init
3781 exit(3 >= 4)
3782 end on
3783 )NKSP_CODE",
3784 .expectBoolExitResult = false
3785 });
3786
3787 runScript({
3788 .code = R"NKSP_CODE(
3789 on init
3790 exit(4 >= 3)
3791 end on
3792 )NKSP_CODE",
3793 .expectBoolExitResult = true
3794 });
3795
3796 runScript({
3797 .code = R"NKSP_CODE(
3798 on init
3799 exit(-4 >= 3)
3800 end on
3801 )NKSP_CODE",
3802 .expectBoolExitResult = false
3803 });
3804
3805 runScript({
3806 .code = R"NKSP_CODE(
3807 on init
3808 exit(3 >= -4)
3809 end on
3810 )NKSP_CODE",
3811 .expectBoolExitResult = true
3812 });
3813
3814 runScript({
3815 .code = R"NKSP_CODE(
3816 on init
3817 exit(123 >= -45)
3818 end on
3819 )NKSP_CODE",
3820 .expectBoolExitResult = true
3821 });
3822
3823 runScript({
3824 .code = R"NKSP_CODE(
3825 on init
3826 exit(-45 >= 123)
3827 end on
3828 )NKSP_CODE",
3829 .expectBoolExitResult = false
3830 });
3831
3832 // real number tests ...
3833
3834 runScript({
3835 .code = R"NKSP_CODE(
3836 on init
3837 exit(3.0 >= 3.0)
3838 end on
3839 )NKSP_CODE",
3840 .expectBoolExitResult = true
3841 });
3842
3843 runScript({
3844 .code = R"NKSP_CODE(
3845 on init
3846 exit(3.1 >= 3.1)
3847 end on
3848 )NKSP_CODE",
3849 .expectBoolExitResult = true
3850 });
3851
3852 runScript({
3853 .code = R"NKSP_CODE(
3854 on init
3855 exit(3.1 >= 3.0)
3856 end on
3857 )NKSP_CODE",
3858 .expectBoolExitResult = true
3859 });
3860
3861 runScript({
3862 .code = R"NKSP_CODE(
3863 on init
3864 exit(3.0 >= 3.1)
3865 end on
3866 )NKSP_CODE",
3867 .expectBoolExitResult = false
3868 });
3869
3870 runScript({
3871 .code = R"NKSP_CODE(
3872 on init
3873 exit(-23.33 >= -23.33)
3874 end on
3875 )NKSP_CODE",
3876 .expectBoolExitResult = true
3877 });
3878
3879 runScript({
3880 .code = R"NKSP_CODE(
3881 on init
3882 exit(23.0 >= -23.0)
3883 end on
3884 )NKSP_CODE",
3885 .expectBoolExitResult = true
3886 });
3887
3888 runScript({
3889 .code = R"NKSP_CODE(
3890 on init
3891 exit(3.0 >= 4.0)
3892 end on
3893 )NKSP_CODE",
3894 .expectBoolExitResult = false
3895 });
3896
3897 runScript({
3898 .code = R"NKSP_CODE(
3899 on init
3900 exit(4.0 >= 3.0)
3901 end on
3902 )NKSP_CODE",
3903 .expectBoolExitResult = true
3904 });
3905
3906 runScript({
3907 .code = R"NKSP_CODE(
3908 on init
3909 exit(-4.0 >= 3.0)
3910 end on
3911 )NKSP_CODE",
3912 .expectBoolExitResult = false
3913 });
3914
3915 runScript({
3916 .code = R"NKSP_CODE(
3917 on init
3918 exit(3.0 >= -4.0)
3919 end on
3920 )NKSP_CODE",
3921 .expectBoolExitResult = true
3922 });
3923
3924 runScript({
3925 .code = R"NKSP_CODE(
3926 on init
3927 exit(123.0 >= -45.0)
3928 end on
3929 )NKSP_CODE",
3930 .expectBoolExitResult = true
3931 });
3932
3933 runScript({
3934 .code = R"NKSP_CODE(
3935 on init
3936 exit(-45.0 >= 123.0)
3937 end on
3938 )NKSP_CODE",
3939 .expectBoolExitResult = false
3940 });
3941
3942 // mixed type tests ...
3943
3944 runScript({
3945 .code = R"NKSP_CODE(
3946 on init
3947 exit(9 >= 9.1)
3948 end on
3949 )NKSP_CODE",
3950 .expectBoolExitResult = false
3951 });
3952
3953 runScript({
3954 .code = R"NKSP_CODE(
3955 on init
3956 exit(9.1 >= 9)
3957 end on
3958 )NKSP_CODE",
3959 .expectBoolExitResult = true
3960 });
3961
3962 runScript({
3963 .code = R"NKSP_CODE(
3964 on init
3965 exit(9 >= 9.0)
3966 end on
3967 )NKSP_CODE",
3968 .expectBoolExitResult = true
3969 });
3970
3971 runScript({
3972 .code = R"NKSP_CODE(
3973 on init
3974 exit(9.0 >= 9)
3975 end on
3976 )NKSP_CODE",
3977 .expectBoolExitResult = true
3978 });
3979
3980 // std unit tests ...
3981
3982 runScript({
3983 .code = R"NKSP_CODE(
3984 on init
3985 exit(13ms >= 14ms)
3986 end on
3987 )NKSP_CODE",
3988 .expectBoolExitResult = false
3989 });
3990
3991 runScript({
3992 .code = R"NKSP_CODE(
3993 on init
3994 exit(14ms >= 13ms)
3995 end on
3996 )NKSP_CODE",
3997 .expectBoolExitResult = true
3998 });
3999
4000 runScript({
4001 .code = R"NKSP_CODE(
4002 on init
4003 exit(1s >= 990ms)
4004 end on
4005 )NKSP_CODE",
4006 .expectBoolExitResult = true
4007 });
4008
4009 runScript({
4010 .code = R"NKSP_CODE(
4011 on init
4012 exit(990ms >= 1s)
4013 end on
4014 )NKSP_CODE",
4015 .expectBoolExitResult = false
4016 });
4017
4018 runScript({
4019 .code = R"NKSP_CODE(
4020 on init
4021 exit(1000ms >= 1s)
4022 end on
4023 )NKSP_CODE",
4024 .expectBoolExitResult = true
4025 });
4026
4027 runScript({
4028 .code = R"NKSP_CODE(
4029 on init
4030 exit(1s >= 1000ms)
4031 end on
4032 )NKSP_CODE",
4033 .expectBoolExitResult = true
4034 });
4035
4036 runScript({
4037 .code = R"NKSP_CODE(
4038 on init
4039 exit(1s >= 1)
4040 end on
4041 )NKSP_CODE",
4042 .expectParseError = true // units on both sides must match
4043 });
4044
4045 runScript({
4046 .code = R"NKSP_CODE(
4047 on init
4048 exit(1 >= 1s)
4049 end on
4050 )NKSP_CODE",
4051 .expectParseError = true // units on both sides must match
4052 });
4053
4054 runScript({
4055 .code = R"NKSP_CODE(
4056 on init
4057 exit(1Hz >= 1B)
4058 end on
4059 )NKSP_CODE",
4060 .expectParseError = true // units on both sides must match
4061 });
4062
4063 runScript({
4064 .code = R"NKSP_CODE(
4065 on init
4066 exit(13.0ms >= 13.1ms)
4067 end on
4068 )NKSP_CODE",
4069 .expectBoolExitResult = false
4070 });
4071
4072 runScript({
4073 .code = R"NKSP_CODE(
4074 on init
4075 exit(13.1ms >= 13.0ms)
4076 end on
4077 )NKSP_CODE",
4078 .expectBoolExitResult = true
4079 });
4080
4081 runScript({
4082 .code = R"NKSP_CODE(
4083 on init
4084 exit(0.9s >= 600.0ms)
4085 end on
4086 )NKSP_CODE",
4087 .expectBoolExitResult = true
4088 });
4089
4090 runScript({
4091 .code = R"NKSP_CODE(
4092 on init
4093 exit(600.0ms >= 0.9s)
4094 end on
4095 )NKSP_CODE",
4096 .expectBoolExitResult = false
4097 });
4098
4099 runScript({
4100 .code = R"NKSP_CODE(
4101 on init
4102 exit(5.1kHz >= 5100.0Hz)
4103 end on
4104 )NKSP_CODE",
4105 .expectBoolExitResult = true
4106 });
4107
4108 runScript({
4109 .code = R"NKSP_CODE(
4110 on init
4111 exit(5100.0Hz >= 5.1kHz)
4112 end on
4113 )NKSP_CODE",
4114 .expectBoolExitResult = true
4115 });
4116
4117 runScript({
4118 .code = R"NKSP_CODE(
4119 on init
4120 exit(1.0Hz >= 1.1)
4121 end on
4122 )NKSP_CODE",
4123 .expectParseError = true // units on both sides must match
4124 });
4125
4126 runScript({
4127 .code = R"NKSP_CODE(
4128 on init
4129 exit(1.2 >= 1.34mdB)
4130 end on
4131 )NKSP_CODE",
4132 .expectParseError = true // units on both sides must match
4133 });
4134
4135 runScript({
4136 .code = R"NKSP_CODE(
4137 on init
4138 exit(9.23us >= 3.14kHz)
4139 end on
4140 )NKSP_CODE",
4141 .expectParseError = true // units on both sides must match
4142 });
4143
4144 // 'final' ('!') operator tests ...
4145 // (should always yield in false for relation operators)
4146
4147 runScript({
4148 .code = R"NKSP_CODE(
4149 on init
4150 exit(!-4 >= !3)
4151 end on
4152 )NKSP_CODE",
4153 .expectBoolExitResult = false,
4154 .expectExitResultFinal = false
4155 });
4156
4157 runScript({
4158 .code = R"NKSP_CODE(
4159 on init
4160 exit(-4 >= 3)
4161 end on
4162 )NKSP_CODE",
4163 .expectBoolExitResult = false,
4164 .expectExitResultFinal = false
4165 });
4166
4167 #if !SILENT_TEST
4168 std::cout << std::endl;
4169 #endif
4170 }
4171
4172 static void testEqualOperator() {
4173 #if !SILENT_TEST
4174 std::cout << "UNIT TEST: equal (=) operator\n";
4175 #endif
4176
4177 // integer tests ...
4178
4179 runScript({
4180 .code = R"NKSP_CODE(
4181 on init
4182 exit(3 = 3)
4183 end on
4184 )NKSP_CODE",
4185 .expectBoolExitResult = true
4186 });
4187
4188 runScript({
4189 .code = R"NKSP_CODE(
4190 on init
4191 exit(4 = 4)
4192 end on
4193 )NKSP_CODE",
4194 .expectBoolExitResult = true
4195 });
4196
4197 runScript({
4198 .code = R"NKSP_CODE(
4199 on init
4200 exit(3 = 4)
4201 end on
4202 )NKSP_CODE",
4203 .expectBoolExitResult = false
4204 });
4205
4206 runScript({
4207 .code = R"NKSP_CODE(
4208 on init
4209 exit(23 = -23)
4210 end on
4211 )NKSP_CODE",
4212 .expectBoolExitResult = false
4213 });
4214
4215 // real number tests ...
4216
4217 runScript({
4218 .code = R"NKSP_CODE(
4219 on init
4220 exit(3.0 = 3.0)
4221 end on
4222 )NKSP_CODE",
4223 .expectBoolExitResult = true
4224 });
4225
4226 runScript({
4227 .code = R"NKSP_CODE(
4228 on init
4229 exit(4.33 = 4.33)
4230 end on
4231 )NKSP_CODE",
4232 .expectBoolExitResult = true
4233 });
4234
4235 runScript({
4236 .code = R"NKSP_CODE(
4237 on init
4238 exit(4.31 = 4.35)
4239 end on
4240 )NKSP_CODE",
4241 .expectBoolExitResult = false
4242 });
4243
4244 runScript({
4245 .code = R"NKSP_CODE(
4246 on init
4247 exit(3.0 = 4.0)
4248 end on
4249 )NKSP_CODE",
4250 .expectBoolExitResult = false
4251 });
4252
4253 runScript({
4254 .code = R"NKSP_CODE(
4255 on init
4256 exit(23.0 = -23.0)
4257 end on
4258 )NKSP_CODE",
4259 .expectBoolExitResult = false
4260 });
4261
4262 // deal with inaccuracy of float point
4263 runScript({
4264 .code = R"NKSP_CODE(
4265 on init
4266 declare ~a := 0.165
4267 declare ~b := 0.185
4268 declare ~x := 0.1
4269 declare ~y := 0.25
4270 exit(~a + ~b = ~x + ~y) { both sides should actually be 0.35, they slightly deviate both though }
4271 end on
4272 )NKSP_CODE",
4273 .expectBoolExitResult = true // our implementation of real number equal comparison should take care about floating point tolerance
4274 });
4275
4276 // deal with inaccuracy of float point
4277 runScript({
4278 .code = R"NKSP_CODE(
4279 on init
4280 declare ~a := 0.166
4281 declare ~b := 0.185
4282 declare ~x := 0.1
4283 declare ~y := 0.25
4284 exit(~a + ~b = ~x + ~y) { left side approx. 0.351, right side approx. 0.35 }
4285 end on
4286 )NKSP_CODE",
4287 .expectBoolExitResult = false
4288 });
4289
4290 // mixed type tests ...
4291
4292 runScript({
4293 .code = R"NKSP_CODE(
4294 on init
4295 exit(23 = 23.0)
4296 end on
4297 )NKSP_CODE",
4298 .expectBoolExitResult = true
4299 });
4300
4301 runScript({
4302 .code = R"NKSP_CODE(
4303 on init
4304 exit(23.0 = 23)
4305 end on
4306 )NKSP_CODE",
4307 .expectBoolExitResult = true
4308 });
4309
4310 runScript({
4311 .code = R"NKSP_CODE(
4312 on init
4313 exit(23 = 23.1)
4314 end on
4315 )NKSP_CODE",
4316 .expectBoolExitResult = false
4317 });
4318
4319 runScript({
4320 .code = R"NKSP_CODE(
4321 on init
4322 exit(23.1 = 23)
4323 end on
4324 )NKSP_CODE",
4325 .expectBoolExitResult = false
4326 });
4327
4328 // std unit tests ...
4329
4330 runScript({
4331 .code = R"NKSP_CODE(
4332 on init
4333 exit(13ms = 14ms)
4334 end on
4335 )NKSP_CODE",
4336 .expectBoolExitResult = false
4337 });
4338
4339 runScript({
4340 .code = R"NKSP_CODE(
4341 on init
4342 exit(14ms = 13ms)
4343 end on
4344 )NKSP_CODE",
4345 .expectBoolExitResult = false
4346 });
4347
4348 runScript({
4349 .code = R"NKSP_CODE(
4350 on init
4351 exit(1s = 1ms)
4352 end on
4353 )NKSP_CODE",
4354 .expectBoolExitResult = false
4355 });
4356
4357 runScript({
4358 .code = R"NKSP_CODE(
4359 on init
4360 exit(1ms = 1s)
4361 end on
4362 )NKSP_CODE",
4363 .expectBoolExitResult = false
4364 });
4365
4366 runScript({
4367 .code = R"NKSP_CODE(
4368 on init
4369 exit(3.14kHz = 3140Hz)
4370 end on
4371 )NKSP_CODE",
4372 .expectBoolExitResult = true
4373 });
4374
4375 runScript({
4376 .code = R"NKSP_CODE(
4377 on init
4378 exit(3140Hz = 3.14kHz)
4379 end on
4380 )NKSP_CODE",
4381 .expectBoolExitResult = true
4382 });
4383
4384 runScript({
4385 .code = R"NKSP_CODE(
4386 on init
4387 exit(1s = 1)
4388 end on
4389 )NKSP_CODE",
4390 .expectParseError = true // units on both sides must match
4391 });
4392
4393 runScript({
4394 .code = R"NKSP_CODE(
4395 on init
4396 exit(1 = 1s)
4397 end on
4398 )NKSP_CODE",
4399 .expectParseError = true // units on both sides must match
4400 });
4401
4402 runScript({
4403 .code = R"NKSP_CODE(
4404 on init
4405 exit(1Hz = 1B)
4406 end on
4407 )NKSP_CODE",
4408 .expectParseError = true // units on both sides must match
4409 });
4410
4411 // 'final' ('!') operator tests ...
4412 // (should always yield in false for relation operators)
4413
4414 runScript({
4415 .code = R"NKSP_CODE(
4416 on init
4417 exit(!-4 = !3)
4418 end on
4419 )NKSP_CODE",
4420 .expectBoolExitResult = false,
4421 .expectExitResultFinal = false
4422 });
4423
4424 runScript({
4425 .code = R"NKSP_CODE(
4426 on init
4427 exit(-4 = 3)
4428 end on
4429 )NKSP_CODE",
4430 .expectBoolExitResult = false,
4431 .expectExitResultFinal = false
4432 });
4433
4434 #if !SILENT_TEST
4435 std::cout << std::endl;
4436 #endif
4437 }
4438
4439 static void testUnequalOperator() {
4440 #if !SILENT_TEST
4441 std::cout << "UNIT TEST: unequal (#) operator\n";
4442 #endif
4443
4444 // integer tests ...
4445
4446 runScript({
4447 .code = R"NKSP_CODE(
4448 on init
4449 exit(3 # 3)
4450 end on
4451 )NKSP_CODE",
4452 .expectBoolExitResult = false
4453 });
4454
4455 runScript({
4456 .code = R"NKSP_CODE(
4457 on init
4458 exit(4 # 4)
4459 end on
4460 )NKSP_CODE",
4461 .expectBoolExitResult = false
4462 });
4463
4464 runScript({
4465 .code = R"NKSP_CODE(
4466 on init
4467 exit(3 # 4)
4468 end on
4469 )NKSP_CODE",
4470 .expectBoolExitResult = true
4471 });
4472
4473 runScript({
4474 .code = R"NKSP_CODE(
4475 on init
4476 exit(23 # -23)
4477 end on
4478 )NKSP_CODE",
4479 .expectBoolExitResult = true
4480 });
4481
4482 // real number tests ...
4483
4484 runScript({
4485 .code = R"NKSP_CODE(
4486 on init
4487 exit(3.0 # 3.0)
4488 end on
4489 )NKSP_CODE",
4490 .expectBoolExitResult = false
4491 });
4492
4493 runScript({
4494 .code = R"NKSP_CODE(
4495 on init
4496 exit(3.14 # 3.14)
4497 end on
4498 )NKSP_CODE",
4499 .expectBoolExitResult = false
4500 });
4501
4502 runScript({
4503 .code = R"NKSP_CODE(
4504 on init
4505 exit(3.19 # 3.12)
4506 end on
4507 )NKSP_CODE",
4508 .expectBoolExitResult = true
4509 });
4510
4511 runScript({
4512 .code = R"NKSP_CODE(
4513 on init
4514 exit(23.0 # -23.0)
4515 end on
4516 )NKSP_CODE",
4517 .expectBoolExitResult = true
4518 });
4519
4520 // deal with inaccuracy of float point
4521 runScript({
4522 .code = R"NKSP_CODE(
4523 on init
4524 declare ~a := 0.165
4525 declare ~b := 0.185
4526 declare ~x := 0.1
4527 declare ~y := 0.25
4528 exit(~a + ~b # ~x + ~y) { both sides should actually be 0.35, they slightly deviate both though }
4529 end on
4530 )NKSP_CODE",
4531 .expectBoolExitResult = false // our implementation of real number unequal comparison should take care about floating point tolerance
4532 });
4533
4534 // deal with inaccuracy of float point
4535 runScript({
4536 .code = R"NKSP_CODE(
4537 on init
4538 declare ~a := 0.166
4539 declare ~b := 0.185
4540 declare ~x := 0.1
4541 declare ~y := 0.25
4542 exit(~a + ~b # ~x + ~y) { left side approx. 0.351, right side approx. 0.35 }
4543 end on
4544 )NKSP_CODE",
4545 .expectBoolExitResult = true
4546 });
4547
4548 // mixed type tests ...
4549
4550 runScript({
4551 .code = R"NKSP_CODE(
4552 on init
4553 exit(3 # 3.0)
4554 end on
4555 )NKSP_CODE",
4556 .expectBoolExitResult = false
4557 });
4558
4559 runScript({
4560 .code = R"NKSP_CODE(
4561 on init
4562 exit(3.0 # 3)
4563 end on
4564 )NKSP_CODE",
4565 .expectBoolExitResult = false
4566 });
4567
4568 runScript({
4569 .code = R"NKSP_CODE(
4570 on init
4571 exit(3.1 # 3)
4572 end on
4573 )NKSP_CODE",
4574 .expectBoolExitResult = true
4575 });
4576
4577 runScript({
4578 .code = R"NKSP_CODE(
4579 on init
4580 exit(3 # 3.1)
4581 end on
4582 )NKSP_CODE",
4583 .expectBoolExitResult = true
4584 });
4585
4586 // std unit tests ...
4587
4588 runScript({
4589 .code = R"NKSP_CODE(
4590 on init
4591 exit(13ms # 14ms)
4592 end on
4593 )NKSP_CODE",
4594 .expectBoolExitResult = true
4595 });
4596
4597 runScript({
4598 .code = R"NKSP_CODE(
4599 on init
4600 exit(14ms # 13ms)
4601 end on
4602 )NKSP_CODE",
4603 .expectBoolExitResult = true
4604 });
4605
4606 runScript({
4607 .code = R"NKSP_CODE(
4608 on init
4609 exit(1s # 1ms)
4610 end on
4611 )NKSP_CODE",
4612 .expectBoolExitResult = true
4613 });
4614
4615 runScript({
4616 .code = R"NKSP_CODE(
4617 on init
4618 exit(1ms # 1s)
4619 end on
4620 )NKSP_CODE",
4621 .expectBoolExitResult = true
4622 });
4623
4624 runScript({
4625 .code = R"NKSP_CODE(
4626 on init
4627 exit(3.14kHz # 3140Hz)
4628 end on
4629 )NKSP_CODE",
4630 .expectBoolExitResult = false
4631 });
4632
4633 runScript({
4634 .code = R"NKSP_CODE(
4635 on init
4636 exit(3140Hz # 3.14kHz)
4637 end on
4638 )NKSP_CODE",
4639 .expectBoolExitResult = false
4640 });
4641
4642 runScript({
4643 .code = R"NKSP_CODE(
4644 on init
4645 exit(1s # 1)
4646 end on
4647 )NKSP_CODE",
4648 .expectParseError = true // units on both sides must match
4649 });
4650
4651 runScript({
4652 .code = R"NKSP_CODE(
4653 on init
4654 exit(1 # 1s)
4655 end on
4656 )NKSP_CODE",
4657 .expectParseError = true // units on both sides must match
4658 });
4659
4660 runScript({
4661 .code = R"NKSP_CODE(
4662 on init
4663 exit(1Hz # 1B)
4664 end on
4665 )NKSP_CODE",
4666 .expectParseError = true // units on both sides must match
4667 });
4668
4669 // 'final' ('!') operator tests ...
4670 // (should always yield in false for relation operators)
4671
4672 runScript({
4673 .code = R"NKSP_CODE(
4674 on init
4675 exit(!-4 # !3)
4676 end on
4677 )NKSP_CODE",
4678 .expectBoolExitResult = true,
4679 .expectExitResultFinal = false
4680 });
4681
4682 runScript({
4683 .code = R"NKSP_CODE(
4684 on init
4685 exit(-4 # 3)
4686 end on
4687 )NKSP_CODE",
4688 .expectBoolExitResult = true,
4689 .expectExitResultFinal = false
4690 });
4691
4692 #if !SILENT_TEST
4693 std::cout << std::endl;
4694 #endif
4695 }
4696
4697 static void testLogicalAndOperator() {
4698 #if !SILENT_TEST
4699 std::cout << "UNIT TEST: logical and (and) operator\n";
4700 #endif
4701
4702 // integer tests ...
4703
4704 runScript({
4705 .code = R"NKSP_CODE(
4706 on init
4707 exit(1 and 1)
4708 end on
4709 )NKSP_CODE",
4710 .expectBoolExitResult = true
4711 });
4712
4713 runScript({
4714 .code = R"NKSP_CODE(
4715 on init
4716 exit(1 and 2)
4717 end on
4718 )NKSP_CODE",
4719 .expectBoolExitResult = true
4720 });
4721
4722 runScript({
4723 .code = R"NKSP_CODE(
4724 on init
4725 exit(1 and 3)
4726 end on
4727 )NKSP_CODE",
4728 .expectBoolExitResult = true
4729 });
4730
4731 runScript({
4732 .code = R"NKSP_CODE(
4733 on init
4734 exit(1 and 0)
4735 end on
4736 )NKSP_CODE",
4737 .expectBoolExitResult = false
4738 });
4739
4740 runScript({
4741 .code = R"NKSP_CODE(
4742 on init
4743 exit(0 and 1)
4744 end on
4745 )NKSP_CODE",
4746 .expectBoolExitResult = false
4747 });
4748
4749 runScript({
4750 .code = R"NKSP_CODE(
4751 on init
4752 exit(0 and 0)
4753 end on
4754 )NKSP_CODE",
4755 .expectBoolExitResult = false
4756 });
4757
4758 // real number tests ...
4759 // (not allowed for this operator)
4760
4761 runScript({
4762 .code = R"NKSP_CODE(
4763 on init
4764 exit(1.0 and 1.0)
4765 end on
4766 )NKSP_CODE",
4767 .expectParseError = true // real numbers not allowed for this operator
4768 });
4769
4770 // mixed type tests ...
4771 // (not allowed for this operator)
4772
4773 runScript({
4774 .code = R"NKSP_CODE(
4775 on init
4776 exit(1.0 and 1)
4777 end on
4778 )NKSP_CODE",
4779 .expectParseError = true // real numbers not allowed for this operator
4780 });
4781
4782 runScript({
4783 .code = R"NKSP_CODE(
4784 on init
4785 exit(1 and 1.0)
4786 end on
4787 )NKSP_CODE",
4788 .expectParseError = true // real numbers not allowed for this operator
4789 });
4790
4791 // std unit tests ...
4792 // (not allowed for this operator)
4793
4794 runScript({
4795 .code = R"NKSP_CODE(
4796 on init
4797 exit(1s and 0)
4798 end on
4799 )NKSP_CODE",
4800 .expectParseError = true // std units not allowed for this operator
4801 });
4802
4803 runScript({
4804 .code = R"NKSP_CODE(
4805 on init
4806 exit(0 and 1s)
4807 end on
4808 )NKSP_CODE",
4809 .expectParseError = true // std units not allowed for this operator
4810 });
4811
4812 // 'final' ('!') operator tests ...
4813
4814 runScript({
4815 .code = R"NKSP_CODE(
4816 on init
4817 exit(!0 and !0)
4818 end on
4819 )NKSP_CODE",
4820 .expectExitResultFinal = true
4821 });
4822
4823 runScript({
4824 .code = R"NKSP_CODE(
4825 on init
4826 exit(0 and 0)
4827 end on
4828 )NKSP_CODE",
4829 .expectExitResultFinal = false
4830 });
4831
4832 #if !SILENT_TEST
4833 std::cout << std::endl;
4834 #endif
4835 }
4836
4837 static void testLogicalOrOperator() {
4838 #if !SILENT_TEST
4839 std::cout << "UNIT TEST: logical or (or) operator\n";
4840 #endif
4841
4842 // integer tests ...
4843
4844 runScript({
4845 .code = R"NKSP_CODE(
4846 on init
4847 exit(1 or 1)
4848 end on
4849 )NKSP_CODE",
4850 .expectBoolExitResult = true
4851 });
4852
4853 runScript({
4854 .code = R"NKSP_CODE(
4855 on init
4856 exit(1 or 2)
4857 end on
4858 )NKSP_CODE",
4859 .expectBoolExitResult = true
4860 });
4861
4862 runScript({
4863 .code = R"NKSP_CODE(
4864 on init
4865 exit(1 or 3)
4866 end on
4867 )NKSP_CODE",
4868 .expectBoolExitResult = true
4869 });
4870
4871 runScript({
4872 .code = R"NKSP_CODE(
4873 on init
4874 exit(1 or 0)
4875 end on
4876 )NKSP_CODE",
4877 .expectBoolExitResult = true
4878 });
4879
4880 runScript({
4881 .code = R"NKSP_CODE(
4882 on init
4883 exit(0 or 1)
4884 end on
4885 )NKSP_CODE",
4886 .expectBoolExitResult = true
4887 });
4888
4889 runScript({
4890 .code = R"NKSP_CODE(
4891 on init
4892 exit(0 or 0)
4893 end on
4894 )NKSP_CODE",
4895 .expectBoolExitResult = false
4896 });
4897
4898 // real number tests ...
4899 // (not allowed for this operator)
4900
4901 runScript({
4902 .code = R"NKSP_CODE(
4903 on init
4904 exit(1.0 or 1.0)
4905 end on
4906 )NKSP_CODE",
4907 .expectParseError = true // real numbers not allowed for this operator
4908 });
4909
4910 // mixed type tests ...
4911 // (not allowed for this operator)
4912
4913 runScript({
4914 .code = R"NKSP_CODE(
4915 on init
4916 exit(1.0 or 1)
4917 end on
4918 )NKSP_CODE",
4919 .expectParseError = true // real numbers not allowed for this operator
4920 });
4921
4922 runScript({
4923 .code = R"NKSP_CODE(
4924 on init
4925 exit(1 or 1.0)
4926 end on
4927 )NKSP_CODE",
4928 .expectParseError = true // real numbers not allowed for this operator
4929 });
4930
4931 // std unit tests ...
4932 // (not allowed for this operator)
4933
4934 runScript({
4935 .code = R"NKSP_CODE(
4936 on init
4937 exit(1s or 0)
4938 end on
4939 )NKSP_CODE",
4940 .expectParseError = true // std units not allowed for this operator
4941 });
4942
4943 runScript({
4944 .code = R"NKSP_CODE(
4945 on init
4946 exit(0 or 1s)
4947 end on
4948 )NKSP_CODE",
4949 .expectParseError = true // std units not allowed for this operator
4950 });
4951
4952 // 'final' ('!') operator tests ...
4953
4954 runScript({
4955 .code = R"NKSP_CODE(
4956 on init
4957 exit(!0 or !0)
4958 end on
4959 )NKSP_CODE",
4960 .expectExitResultFinal = true
4961 });
4962
4963 runScript({
4964 .code = R"NKSP_CODE(
4965 on init
4966 exit(0 or 0)
4967 end on
4968 )NKSP_CODE",
4969 .expectExitResultFinal = false
4970 });
4971
4972 #if !SILENT_TEST
4973 std::cout << std::endl;
4974 #endif
4975 }
4976
4977 static void testLogicalNotOperator() {
4978 #if !SILENT_TEST
4979 std::cout << "UNIT TEST: logical not (not) operator\n";
4980 #endif
4981
4982 // integer tests ...
4983
4984 runScript({
4985 .code = R"NKSP_CODE(
4986 on init
4987 exit(not 1)
4988 end on
4989 )NKSP_CODE",
4990 .expectBoolExitResult = false
4991 });
4992
4993 runScript({
4994 .code = R"NKSP_CODE(
4995 on init
4996 exit(not 2)
4997 end on
4998 )NKSP_CODE",
4999 .expectBoolExitResult = false
5000 });
5001
5002 runScript({
5003 .code = R"NKSP_CODE(
5004 on init
5005 exit(not 0)
5006 end on
5007 )NKSP_CODE",
5008 .expectBoolExitResult = true
5009 });
5010
5011 // real number tests ...
5012 // (not allowed for this operator)
5013
5014 runScript({
5015 .code = R"NKSP_CODE(
5016 on init
5017 exit(not 1.0)
5018 end on
5019 )NKSP_CODE",
5020 .expectParseError = true // real numbers not allowed for this operator
5021 });
5022
5023 // std unit tests ...
5024 // (not allowed for this operator)
5025
5026 runScript({
5027 .code = R"NKSP_CODE(
5028 on init
5029 exit(not 1s)
5030 end on
5031 )NKSP_CODE",
5032 .expectParseError = true // std units not allowed for this operator
5033 });
5034
5035 // 'final' ('!') operator tests ...
5036
5037 runScript({
5038 .code = R"NKSP_CODE(
5039 on init
5040 exit(not !1)
5041 end on
5042 )NKSP_CODE",
5043 .expectExitResultFinal = true
5044 });
5045
5046 runScript({
5047 .code = R"NKSP_CODE(
5048 on init
5049 exit(not 1)
5050 end on
5051 )NKSP_CODE",
5052 .expectExitResultFinal = false
5053 });
5054
5055 #if !SILENT_TEST
5056 std::cout << std::endl;
5057 #endif
5058 }
5059
5060 static void testBitwiseAndOperator() {
5061 #if !SILENT_TEST
5062 std::cout << "UNIT TEST: bitwise and (.and.) operator\n";
5063 #endif
5064
5065 // integer tests ...
5066
5067 runScript({
5068 .code = R"NKSP_CODE(
5069 on init
5070 exit(1 .and. 1)
5071 end on
5072 )NKSP_CODE",
5073 .expectIntExitResult = 1
5074 });
5075
5076 runScript({
5077 .code = R"NKSP_CODE(
5078 on init
5079 exit(43 .and. 142)
5080 end on
5081 )NKSP_CODE",
5082 .expectIntExitResult = 10
5083 });
5084
5085 // real number tests ...
5086 // (not allowed for this operator)
5087
5088 runScript({
5089 .code = R"NKSP_CODE(
5090 on init
5091 exit(1.0 .and. 1.0)
5092 end on
5093 )NKSP_CODE",
5094 .expectParseError = true // real numbers not allowed for this operator
5095 });
5096
5097 // mixed type tests ...
5098 // (not allowed for this operator)
5099
5100 runScript({
5101 .code = R"NKSP_CODE(
5102 on init
5103 exit(1.0 .and. 1)
5104 end on
5105 )NKSP_CODE",
5106 .expectParseError = true // real numbers not allowed for this operator
5107 });
5108
5109 runScript({
5110 .code = R"NKSP_CODE(
5111 on init
5112 exit(1 .and. 1.0)
5113 end on
5114 )NKSP_CODE",
5115 .expectParseError = true // real numbers not allowed for this operator
5116 });
5117
5118 // std unit tests ...
5119 // (not allowed for this operator)
5120
5121 runScript({
5122 .code = R"NKSP_CODE(
5123 on init
5124 exit(1s .and. 1)
5125 end on
5126 )NKSP_CODE",
5127 .expectParseError = true // std units not allowed for this operator
5128 });
5129
5130 runScript({
5131 .code = R"NKSP_CODE(
5132 on init
5133 exit(1 .and. 1s)
5134 end on
5135 )NKSP_CODE",
5136 .expectParseError = true // std units not allowed for this operator
5137 });
5138
5139 // 'final' ('!') operator tests ...
5140
5141 runScript({
5142 .code = R"NKSP_CODE(
5143 on init
5144 exit(!43 .and. !142)
5145 end on
5146 )NKSP_CODE",
5147 .expectIntExitResult = 10,
5148 .expectExitResultFinal = true
5149 });
5150
5151 runScript({
5152 .code = R"NKSP_CODE(
5153 on init
5154 exit(43 .and. 142)
5155 end on
5156 )NKSP_CODE",
5157 .expectIntExitResult = 10,
5158 .expectExitResultFinal = false
5159 });
5160
5161 #if !SILENT_TEST
5162 std::cout << std::endl;
5163 #endif
5164 }
5165
5166 static void testBitwiseOrOperator() {
5167 #if !SILENT_TEST
5168 std::cout << "UNIT TEST: bitwise or (.or.) operator\n";
5169 #endif
5170
5171 // integer tests ...
5172
5173 runScript({
5174 .code = R"NKSP_CODE(
5175 on init
5176 exit(1 .or. 1)
5177 end on
5178 )NKSP_CODE",
5179 .expectIntExitResult = 1
5180 });
5181
5182 runScript({
5183 .code = R"NKSP_CODE(
5184 on init
5185 exit(0 .or. 0)
5186 end on
5187 )NKSP_CODE",
5188 .expectIntExitResult = 0
5189 });
5190
5191 runScript({
5192 .code = R"NKSP_CODE(
5193 on init
5194 exit(43 .or. 142)
5195 end on
5196 )NKSP_CODE",
5197 .expectIntExitResult = 175
5198 });
5199
5200 // real number tests ...
5201 // (not allowed for this operator)
5202
5203 runScript({
5204 .code = R"NKSP_CODE(
5205 on init
5206 exit(1.0 .or. 1.0)
5207 end on
5208 )NKSP_CODE",
5209 .expectParseError = true // real numbers not allowed for this operator
5210 });
5211
5212 // mixed type tests ...
5213 // (not allowed for this operator)
5214
5215 runScript({
5216 .code = R"NKSP_CODE(
5217 on init
5218 exit(1.0 .or. 1)
5219 end on
5220 )NKSP_CODE",
5221 .expectParseError = true // real numbers not allowed for this operator
5222 });
5223
5224 runScript({
5225 .code = R"NKSP_CODE(
5226 on init
5227 exit(1 .or. 1.0)
5228 end on
5229 )NKSP_CODE",
5230 .expectParseError = true // real numbers not allowed for this operator
5231 });
5232
5233 // std unit tests ...
5234 // (not allowed for this operator)
5235
5236 runScript({
5237 .code = R"NKSP_CODE(
5238 on init
5239 exit(1s .or. 1)
5240 end on
5241 )NKSP_CODE",
5242 .expectParseError = true // std units not allowed for this operator
5243 });
5244
5245 runScript({
5246 .code = R"NKSP_CODE(
5247 on init
5248 exit(1 .or. 1s)
5249 end on
5250 )NKSP_CODE",
5251 .expectParseError = true // std units not allowed for this operator
5252 });
5253
5254 // 'final' ('!') operator tests ...
5255
5256 runScript({
5257 .code = R"NKSP_CODE(
5258 on init
5259 exit(!43 .or. !142)
5260 end on
5261 )NKSP_CODE",
5262 .expectIntExitResult = 175,
5263 .expectExitResultFinal = true
5264 });
5265
5266 runScript({
5267 .code = R"NKSP_CODE(
5268 on init
5269 exit(43 .or. 142)
5270 end on
5271 )NKSP_CODE",
5272 .expectIntExitResult = 175,
5273 .expectExitResultFinal = false
5274 });
5275
5276 #if !SILENT_TEST
5277 std::cout << std::endl;
5278 #endif
5279 }
5280
5281 static void testBitwiseNotOperator() {
5282 #if !SILENT_TEST
5283 std::cout << "UNIT TEST: bitwise not (.not.) operator\n";
5284 #endif
5285
5286 // integer tests ...
5287
5288 runScript({
5289 .code = R"NKSP_CODE(
5290 on init
5291 exit(.not. -1)
5292 end on
5293 )NKSP_CODE",
5294 .expectIntExitResult = 0
5295 });
5296
5297 runScript({
5298 .code = R"NKSP_CODE(
5299 on init
5300 exit(.not. 0)
5301 end on
5302 )NKSP_CODE",
5303 .expectIntExitResult = -1
5304 });
5305
5306 runScript({
5307 .code = R"NKSP_CODE(
5308 on init
5309 exit(.not. 3)
5310 end on
5311 )NKSP_CODE",
5312 .expectIntExitResult = ssize_t(size_t(-1) << 2)
5313 });
5314
5315 // real number tests ...
5316 // (not allowed for this operator)
5317
5318 runScript({
5319 .code = R"NKSP_CODE(
5320 on init
5321 exit(.not. 1.0)
5322 end on
5323 )NKSP_CODE",
5324 .expectParseError = true // real numbers not allowed for this operator
5325 });
5326
5327 runScript({
5328 .code = R"NKSP_CODE(
5329 on init
5330 exit(.not. -1.0)
5331 end on
5332 )NKSP_CODE",
5333 .expectParseError = true // real numbers not allowed for this operator
5334 });
5335
5336 // std unit tests ...
5337 // (not allowed for this operator)
5338
5339 runScript({
5340 .code = R"NKSP_CODE(
5341 on init
5342 exit(.not. 1s)
5343 end on
5344 )NKSP_CODE",
5345 .expectParseError = true // std units not allowed for this operator
5346 });
5347
5348 // 'final' ('!') operator tests ...
5349
5350 runScript({
5351 .code = R"NKSP_CODE(
5352 on init
5353 exit(.not. !0)
5354 end on
5355 )NKSP_CODE",
5356 .expectIntExitResult = -1,
5357 .expectExitResultFinal = true
5358 });
5359
5360 runScript({
5361 .code = R"NKSP_CODE(
5362 on init
5363 exit(.not. 0)
5364 end on
5365 )NKSP_CODE",
5366 .expectIntExitResult = -1,
5367 .expectExitResultFinal = false
5368 });
5369
5370 #if !SILENT_TEST
5371 std::cout << std::endl;
5372 #endif
5373 }
5374
5375 static void testPrecedenceOfOperators() {
5376 #if !SILENT_TEST
5377 std::cout << "UNIT TEST: precedence of operators\n";
5378 #endif
5379
5380 // integer tests ...
5381
5382 runScript({
5383 .code = R"NKSP_CODE(
5384 on init
5385 exit(3 + 4 * 2)
5386 end on
5387 )NKSP_CODE",
5388 .expectIntExitResult = 11
5389 });
5390
5391 runScript({
5392 .code = R"NKSP_CODE(
5393 on init
5394 exit(4 * 2 + 3)
5395 end on
5396 )NKSP_CODE",
5397 .expectIntExitResult = 11
5398 });
5399
5400 runScript({
5401 .code = R"NKSP_CODE(
5402 on init
5403 exit((3 + 4) * 2)
5404 end on
5405 )NKSP_CODE",
5406 .expectIntExitResult = 14
5407 });
5408
5409 runScript({
5410 .code = R"NKSP_CODE(
5411 on init
5412 exit(4 * (2 + 3))
5413 end on
5414 )NKSP_CODE",
5415 .expectIntExitResult = 20
5416 });
5417
5418 // real number tests ...
5419
5420 runScript({
5421 .code = R"NKSP_CODE(
5422 on init
5423 exit(3.2 + 4.0 * 2.0)
5424 end on
5425 )NKSP_CODE",
5426 .expectRealExitResult = 11.2
5427 });
5428
5429 runScript({
5430 .code = R"NKSP_CODE(
5431 on init
5432 exit(4.0 * 2.0 + 3.2)
5433 end on
5434 )NKSP_CODE",
5435 .expectRealExitResult = 11.2
5436 });
5437
5438 runScript({
5439 .code = R"NKSP_CODE(
5440 on init
5441 exit((3.2 + 4.0) * 2.0)
5442 end on
5443 )NKSP_CODE",
5444 .expectRealExitResult = 14.4
5445 });
5446
5447 runScript({
5448 .code = R"NKSP_CODE(
5449 on init
5450 exit(4.0 * (2.0 + 3.2))
5451 end on
5452 )NKSP_CODE",
5453 .expectRealExitResult = 20.8
5454 });
5455
5456 // std unit tests ...
5457
5458 runScript({
5459 .code = R"NKSP_CODE(
5460 on init
5461 exit(4 * (2us + 3us) + 7ms)
5462 end on
5463 )NKSP_CODE",
5464 .expectIntExitResult = 7020,
5465 .expectExitResultUnitPrefix = { VM_MICRO },
5466 .expectExitResultUnit = VM_SECOND
5467 });
5468
5469 runScript({
5470 .code = R"NKSP_CODE(
5471 on init
5472 declare $a := 4
5473 declare $c := 3us
5474 exit($a * (2us + $c) + 7ms)
5475 end on
5476 )NKSP_CODE",
5477 .expectIntExitResult = 7020,
5478 .expectExitResultUnitPrefix = { VM_MICRO },
5479 .expectExitResultUnit = VM_SECOND
5480 });
5481
5482 runScript({
5483 .code = R"NKSP_CODE(
5484 on init
5485 declare $a := 4
5486 declare $b := 2us
5487 declare $c := 3us
5488 exit($a * ($b + $c) + 7ms)
5489 end on
5490 )NKSP_CODE",
5491 .expectIntExitResult = 7020,
5492 .expectExitResultUnitPrefix = { VM_MICRO },
5493 .expectExitResultUnit = VM_SECOND
5494 });
5495
5496 runScript({
5497 .code = R"NKSP_CODE(
5498 on init
5499 declare $a := 4
5500 declare $b := 2us
5501 declare $c := 3us
5502 declare $d := 7ms
5503 exit($a * ($b + $c) + 7ms)
5504 end on
5505 )NKSP_CODE",
5506 .expectIntExitResult = 7020,
5507 .expectExitResultUnitPrefix = { VM_MICRO },
5508 .expectExitResultUnit = VM_SECOND
5509 });
5510
5511 runScript({
5512 .code = R"NKSP_CODE(
5513 on init
5514 declare $c := 3us
5515 declare $a := 4
5516 declare $d := 7ms
5517 declare $b := 2us
5518 exit($a * ($b + $c) + 7ms)
5519 end on
5520 )NKSP_CODE",
5521 .expectIntExitResult = 7020,
5522 .expectExitResultUnitPrefix = { VM_MICRO },
5523 .expectExitResultUnit = VM_SECOND
5524 });
5525
5526 runScript({
5527 .code = R"NKSP_CODE(
5528 on init
5529 exit(4.0 * (2.0mdB + 3.2mdB) / 2.0)
5530 end on
5531 )NKSP_CODE",
5532 .expectRealExitResult = 10.4,
5533 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
5534 .expectExitResultUnit = VM_BEL
5535 });
5536
5537 runScript({
5538 .code = R"NKSP_CODE(
5539 on init
5540 declare ~a := 2.0mdB
5541 declare ~b := 3.2mdB
5542 exit(4.0 * (~a + ~b) / 2.0)
5543 end on
5544 )NKSP_CODE",
5545 .expectRealExitResult = 10.4,
5546 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
5547 .expectExitResultUnit = VM_BEL
5548 });
5549
5550 runScript({
5551 .code = R"NKSP_CODE(
5552 on init
5553 declare ~b := 3.2mdB
5554 declare ~a := 2.0mdB
5555 exit(4.0 * (~a + ~b) / 2.0)
5556 end on
5557 )NKSP_CODE",
5558 .expectRealExitResult = 10.4,
5559 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
5560 .expectExitResultUnit = VM_BEL
5561 });
5562
5563 runScript({
5564 .code = R"NKSP_CODE(
5565 on init
5566 declare ~a := 4.0
5567 declare ~b := 2.0mdB
5568 declare ~c := 3.2mdB
5569 declare ~d := 2.0
5570 exit((~a * (~b + ~c) / ~d) + 1.1mdB)
5571 end on
5572 )NKSP_CODE",
5573 .expectRealExitResult = 11.5,
5574 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
5575 .expectExitResultUnit = VM_BEL
5576 });
5577
5578 runScript({
5579 .code = R"NKSP_CODE(
5580 on init
5581 declare ~c := 3.2mdB
5582 declare ~a := 4.0
5583 declare ~d := 2.0
5584 declare ~b := 2.0mdB
5585 exit(~a * (~b + ~c) / ~d + 1.1mdB)
5586 end on
5587 )NKSP_CODE",
5588 .expectRealExitResult = 11.5,
5589 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
5590 .expectExitResultUnit = VM_BEL
5591 });
5592
5593 // 'final' ('!') operator tests ...
5594
5595 runScript({
5596 .code = R"NKSP_CODE(
5597 on init
5598 declare $a := 4
5599 declare $b := !2us
5600 declare $c := 3us
5601 declare $d := 7ms
5602 exit($a * ($b + $c) + 7ms)
5603 end on
5604 )NKSP_CODE",
5605 .expectIntExitResult = 7020,
5606 .expectExitResultUnitPrefix = { VM_MICRO },
5607 .expectExitResultUnit = VM_SECOND,
5608 .expectExitResultFinal = true,
5609 .expectParseWarning = true // only one operand is defined as 'final', result will be final though
5610 });
5611
5612 runScript({
5613 .code = R"NKSP_CODE(
5614 on init
5615 declare $a := 4
5616 declare $b := 2us
5617 declare $c := !3us
5618 declare $d := 7ms
5619 exit($a * ($b + $c) + 7ms)
5620 end on
5621 )NKSP_CODE",
5622 .expectIntExitResult = 7020,
5623 .expectExitResultUnitPrefix = { VM_MICRO },
5624 .expectExitResultUnit = VM_SECOND,
5625 .expectExitResultFinal = true,
5626 .expectParseWarning = true // only one operand is defined as 'final', result will be final though
5627 });
5628
5629 #if !SILENT_TEST
5630 std::cout << std::endl;
5631 #endif
5632 }
5633
5634 static void testIntVarDeclaration() {
5635 #if !SILENT_TEST
5636 std::cout << "UNIT TEST: int var declaration\n";
5637 #endif
5638
5639 runScript({
5640 .code = R"NKSP_CODE(
5641 on init
5642 declare $a
5643 exit($a)
5644 end on
5645 )NKSP_CODE",
5646 .expectIntExitResult = 0
5647 });
5648
5649 runScript({
5650 .code = R"NKSP_CODE(
5651 on init
5652 declare $a := 24
5653 exit($a)
5654 end on
5655 )NKSP_CODE",
5656 .expectIntExitResult = 24
5657 });
5658
5659 runScript({
5660 .code = R"NKSP_CODE(
5661 on init
5662 declare $a := 24
5663 $a := 8
5664 exit($a)
5665 end on
5666 )NKSP_CODE",
5667 .expectIntExitResult = 8
5668 });
5669
5670 runScript({
5671 .code = R"NKSP_CODE(
5672 on init
5673 declare $a
5674 declare $a
5675 end on
5676 )NKSP_CODE",
5677 .expectParseError = true // variable re-declaration
5678 });
5679
5680 runScript({
5681 .code = R"NKSP_CODE(
5682 on init
5683 declare const $a
5684 end on
5685 )NKSP_CODE",
5686 .expectParseError = true // const variable declaration without assignment
5687 });
5688
5689 runScript({
5690 .code = R"NKSP_CODE(
5691 on init
5692 declare const $a := 24
5693 exit($a)
5694 end on
5695 )NKSP_CODE",
5696 .expectIntExitResult = 24
5697 });
5698
5699 runScript({
5700 .code = R"NKSP_CODE(
5701 on init
5702 declare const $a := 24
5703 $a := 8
5704 end on
5705 )NKSP_CODE",
5706 .expectParseError = true // attempt to modify const variable
5707 });
5708
5709 runScript({
5710 .code = R"NKSP_CODE(
5711 on init
5712 declare const $a := 24
5713 declare const $b := $a
5714 exit($b)
5715 end on
5716 )NKSP_CODE",
5717 .expectIntExitResult = 24
5718 });
5719
5720 runScript({
5721 .code = R"NKSP_CODE(
5722 on init
5723 declare $a := 24
5724 declare const $b := $a
5725 end on
5726 )NKSP_CODE",
5727 .expectParseError = true // const variable defined with non-const assignment
5728 });
5729
5730 runScript({
5731 .code = R"NKSP_CODE(
5732 on init
5733 declare polyphonic $a
5734 exit($a)
5735 end on
5736 )NKSP_CODE",
5737 .expectIntExitResult = 0
5738 });
5739
5740 runScript({
5741 .code = R"NKSP_CODE(
5742 on init
5743 declare const polyphonic $a
5744 end on
5745 )NKSP_CODE",
5746 .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
5747 });
5748
5749 runScript({
5750 .code = R"NKSP_CODE(
5751 on init
5752 declare polyphonic const $a
5753 end on
5754 )NKSP_CODE",
5755 .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
5756 });
5757
5758 runScript({
5759 .code = R"NKSP_CODE(
5760 on init
5761 declare const polyphonic $a := 3
5762 end on
5763 )NKSP_CODE",
5764 .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
5765 });
5766
5767 runScript({
5768 .code = R"NKSP_CODE(
5769 on init
5770 declare polyphonic const $a := 3
5771 end on
5772 )NKSP_CODE",
5773 .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
5774 });
5775
5776 runScript({
5777 .code = R"NKSP_CODE(
5778 on init
5779 declare ~a := 24
5780 exit(~a)
5781 end on
5782 )NKSP_CODE",
5783 .expectParseWarning = true, // real type declaration vs. int value assignment
5784 .expectIntExitResult = 24
5785 });
5786
5787 runScript({
5788 .code = R"NKSP_CODE(
5789 on init
5790 declare %a := 24
5791 exit(%a)
5792 end on
5793 )NKSP_CODE",
5794 .expectParseWarning = true, // int array type declaration vs. int scalar value assignment
5795 .expectIntExitResult = 24
5796 });
5797
5798 runScript({
5799 .code = R"NKSP_CODE(
5800 on init
5801 declare const %a := 24
5802 exit(%a)
5803 end on
5804 )NKSP_CODE",
5805 .expectParseWarning = true, // int array type declaration vs. int scalar value assignment
5806 .expectIntExitResult = 24
5807 });
5808
5809 runScript({
5810 .code = R"NKSP_CODE(
5811 on init
5812 declare ?a := 24
5813 exit(?a)
5814 end on
5815 )NKSP_CODE",
5816 .expectParseWarning = true, // real array type declaration vs. int scalar value assignment
5817 .expectIntExitResult = 24
5818 });
5819
5820 runScript({
5821 .code = R"NKSP_CODE(
5822 on init
5823 declare const ?a := 24
5824 exit(?a)
5825 end on
5826 )NKSP_CODE",
5827 .expectParseWarning = true, // real array type declaration vs. int scalar value assignment
5828 .expectIntExitResult = 24
5829 });
5830
5831 runScript({
5832 .code = R"NKSP_CODE(
5833 on init
5834 declare @a := 24
5835 exit(@a)
5836 end on
5837 )NKSP_CODE",
5838 .expectParseWarning = true, // string type declaration vs. int scalar value assignment
5839 .expectIntExitResult = 24
5840 });
5841
5842 runScript({
5843 .code = R"NKSP_CODE(
5844 on init
5845 declare const @a := 24
5846 exit(@a)
5847 end on
5848 )NKSP_CODE",
5849 .expectParseWarning = true, // string type declaration vs. int scalar value assignment
5850 .expectIntExitResult = 24
5851 });
5852
5853 runScript({
5854 .code = R"NKSP_CODE(
5855 on init
5856 declare $a := ( 0, 1, 2 )
5857 end on
5858 )NKSP_CODE",
5859 .expectParseError = true // int scalar type declaration vs. int array value assignment
5860 });
5861
5862 runScript({
5863 .code = R"NKSP_CODE(
5864 on init
5865 declare const $a := ( 0, 1, 2 )
5866 end on
5867 )NKSP_CODE",
5868 .expectParseError = true // int scalar type declaration vs. int array value assignment
5869 });
5870
5871 runScript({
5872 .code = R"NKSP_CODE(
5873 on init
5874 declare a
5875 end on
5876 )NKSP_CODE",
5877 .expectParseError = true // missing type prefix character in variable name
5878 });
5879
5880 runScript({
5881 .code = R"NKSP_CODE(
5882 on init
5883 declare a := 24
5884 end on
5885 )NKSP_CODE",
5886 .expectParseError = true // missing type prefix character in variable name
5887 });
5888
5889 runScript({
5890 .code = R"NKSP_CODE(
5891 on init
5892 declare const a := 24
5893 end on
5894 )NKSP_CODE",
5895 .expectParseError = true // missing type prefix character in variable name
5896 });
5897
5898 runScript({
5899 .code = R"NKSP_CODE(
5900 on init
5901 declare polyphonic a
5902 end on
5903 )NKSP_CODE",
5904 .expectParseError = true // missing type prefix character in variable name
5905 });
5906
5907 runScript({
5908 .code = R"NKSP_CODE(
5909 on init
5910 declare $a := max(8,24)
5911 exit($a)
5912 end on
5913 )NKSP_CODE",
5914 .expectIntExitResult = 24
5915 });
5916
5917 runScript({
5918 .code = R"NKSP_CODE(
5919 on init
5920 declare $a := abort($NI_CALLBACK_ID)
5921 end on
5922 )NKSP_CODE",
5923 .expectParseError = true // assigned expression does not result in a value
5924 });
5925
5926 runScript({
5927 .code = R"NKSP_CODE(
5928 on init
5929 declare const $a := abort($NI_CALLBACK_ID)
5930 end on
5931 )NKSP_CODE",
5932 .expectParseError = true // assigned expression does not result in a value
5933 });
5934
5935 #if !SILENT_TEST
5936 std::cout << std::endl;
5937 #endif
5938 }
5939
5940 static void testIntArrayVarDeclaration() {
5941 #if !SILENT_TEST
5942 std::cout << "UNIT TEST: int array var declaration\n";
5943 #endif
5944
5945 runScript({
5946 .code = R"NKSP_CODE(
5947 on init
5948 declare %a[3]
5949 exit( %a[0] + %a[1] + %a[2] )
5950 end on
5951 )NKSP_CODE",
5952 .expectIntExitResult = 0
5953 });
5954
5955 runScript({
5956 .code = R"NKSP_CODE(
5957 on init
5958 declare %a[0]
5959 end on
5960 )NKSP_CODE",
5961 .expectParseWarning = true // unusable array size
5962 });
5963
5964 runScript({
5965 .code = R"NKSP_CODE(
5966 on init
5967 declare %a[-1]
5968 end on
5969 )NKSP_CODE",
5970 .expectParseError = true // illegal array size
5971 });
5972
5973 runScript({
5974 .code = R"NKSP_CODE(
5975 on init
5976 declare %a[3] := ( 1, 2, 3 )
5977 exit( %a[0] + %a[1] + %a[2] )
5978 end on
5979 )NKSP_CODE",
5980 .expectIntExitResult = (1 + 2 + 3)
5981 });
5982
5983 runScript({
5984 .code = R"NKSP_CODE(
5985 on init
5986 declare %a[4] := ( 1, 2, 3 )
5987 exit( %a[0] + %a[1] + %a[2] + %a[3] )
5988 end on
5989 )NKSP_CODE",
5990 .expectParseWarning = true, // less values assigned than array size declared
5991 .expectIntExitResult = (1 + 2 + 3 + 0)
5992 });
5993
5994 runScript({
5995 .code = R"NKSP_CODE(
5996 on init
5997 declare %a[] := ( 1, 2, 3 )
5998 exit( %a[0] + %a[1] + %a[2] )
5999 end on
6000 )NKSP_CODE",
6001 .expectIntExitResult = (1 + 2 + 3)
6002 });
6003
6004 runScript({
6005 .code = R"NKSP_CODE(
6006 on init
6007 declare %a[]
6008 end on
6009 )NKSP_CODE",
6010 .expectParseWarning = true // unusable array size (zero)
6011 });
6012
6013 runScript({
6014 .code = R"NKSP_CODE(
6015 on init
6016 declare const $sz := 3
6017 declare %a[$sz] := ( 1, 2, 3 )
6018 exit( %a[0] + %a[1] + %a[2] )
6019 end on
6020 )NKSP_CODE",
6021 .expectIntExitResult = (1 + 2 + 3)
6022 });
6023
6024 runScript({
6025 .code = R"NKSP_CODE(
6026 on init
6027 declare const $sz := 3
6028 declare const %a[$sz] := ( 1, 2, 3 )
6029 exit( %a[0] + %a[1] + %a[2] )
6030 end on
6031 )NKSP_CODE",
6032 .expectIntExitResult = (1 + 2 + 3)
6033 });
6034
6035 runScript({
6036 .code = R"NKSP_CODE(
6037 on init
6038 declare $sz := 3
6039 declare %a[$sz] := ( 1, 2, 3 )
6040 end on
6041 )NKSP_CODE",
6042 .expectParseError = true // array size must be constant expression
6043 });
6044
6045 runScript({
6046 .code = R"NKSP_CODE(
6047 on init
6048 declare $sz := 3
6049 declare const %a[$sz] := ( 1, 2, 3 )
6050 end on
6051 )NKSP_CODE",
6052 .expectParseError = true // array size must be constant expression
6053 });
6054
6055 runScript({
6056 .code = R"NKSP_CODE(
6057 on init
6058 declare const ~sz := 3.0
6059 declare const %a[~sz] := ( 1, 2, 3 )
6060 end on
6061 )NKSP_CODE",
6062 .expectParseError = true // array size must be integer type
6063 });
6064
6065 runScript({
6066 .code = R"NKSP_CODE(
6067 on init
6068 declare %a[3s] := ( 1, 2, 3 )
6069 end on
6070 )NKSP_CODE",
6071 .expectParseError = true // units not allowed for array size
6072 });
6073
6074 runScript({
6075 .code = R"NKSP_CODE(
6076 on init
6077 declare %a[3m] := ( 1, 2, 3 )
6078 end on
6079 )NKSP_CODE",
6080 .expectParseError = true // units not allowed for array size
6081 });
6082
6083 runScript({
6084 .code = R"NKSP_CODE(
6085 on init
6086 declare const %a[!3] := ( 1, 2, 3 )
6087 exit( %a[0] + %a[1] + %a[2] )
6088 end on
6089 )NKSP_CODE",
6090 .expectIntExitResult = (1 + 2 + 3),
6091 .expectParseWarning = true // 'final' operator is meaningless for array size
6092 });
6093
6094 runScript({
6095 .code = R"NKSP_CODE(
6096 on init
6097 declare %a[3] := ( 1, 2, 3 )
6098 %a[0] := 4
6099 %a[1] := 5
6100 %a[2] := 6
6101 exit( %a[0] + %a[1] + %a[2] )
6102 end on
6103 )NKSP_CODE",
6104 .expectIntExitResult = (4 + 5 + 6)
6105 });
6106
6107 runScript({
6108 .code = R"NKSP_CODE(
6109 on init
6110 declare %a[3]
6111 declare %a[3]
6112 end on
6113 )NKSP_CODE",
6114 .expectParseError = true // variable re-declaration
6115 });
6116
6117 runScript({
6118 .code = R"NKSP_CODE(
6119 on init
6120 declare const %a[3]
6121 end on
6122 )NKSP_CODE",
6123 .expectParseError = true // const variable declaration without assignment
6124 });
6125
6126 runScript({
6127 .code = R"NKSP_CODE(
6128 on init
6129 declare const %a[3] := ( 1, 2, 3 )
6130 exit( %a[0] + %a[1] + %a[2] )
6131 end on
6132 )NKSP_CODE",
6133 .expectIntExitResult = (1 + 2 + 3)
6134 });
6135
6136 runScript({
6137 .code = R"NKSP_CODE(
6138 on init
6139 declare const %a[3] := ( 1, 2, 3, 4 )
6140 end on
6141 )NKSP_CODE",
6142 .expectParseError = true // incompatible array sizes
6143 });
6144
6145 runScript({
6146 .code = R"NKSP_CODE(
6147 on init
6148 declare const %a[3] := ( 1, 2, 3 )
6149 %a[0] := 8
6150 end on
6151 )NKSP_CODE",
6152 .expectParseError = true // attempt to modify const variable
6153 });
6154
6155 runScript({
6156 .code = R"NKSP_CODE(
6157 on init
6158 declare const %a[3] := ( 1, 2, 3 )
6159 declare const %b[3] := ( %a[0], %a[1], %a[2] )
6160 exit( %b[0] + %b[1] + %b[2] )
6161 end on
6162 )NKSP_CODE",
6163 .expectIntExitResult = (1 + 2 + 3)
6164 });
6165
6166 runScript({
6167 .code = R"NKSP_CODE(
6168 on init
6169 declare %a[3] := ( 1, 2, 3 )
6170 declare const %b[3] := ( %a[0], %a[1], %a[2] )
6171 end on
6172 )NKSP_CODE",
6173 .expectParseError = true // const array defined with non-const assignment
6174 });
6175
6176 runScript({
6177 .code = R"NKSP_CODE(
6178 on init
6179 declare polyphonic %a[3]
6180 end on
6181 )NKSP_CODE",
6182 .expectParseError = true // polyphonic not allowed for array types
6183 });
6184
6185 runScript({
6186 .code = R"NKSP_CODE(
6187 on init
6188 declare polyphonic %a[3] := ( 1, 2, 3 )
6189 end on
6190 )NKSP_CODE",
6191 .expectParseError = true // polyphonic not allowed for array types
6192 });
6193
6194 runScript({
6195 .code = R"NKSP_CODE(
6196 on init
6197 declare const polyphonic %a[3]
6198 end on
6199 )NKSP_CODE",
6200 .expectParseError = true // polyphonic not allowed for array types
6201 });
6202
6203 runScript({
6204 .code = R"NKSP_CODE(
6205 on init
6206 declare const polyphonic %a[3] := ( 1, 2, 3 )
6207 end on
6208 )NKSP_CODE",
6209 .expectParseError = true // polyphonic not allowed for array types
6210 });
6211
6212 runScript({
6213 .code = R"NKSP_CODE(
6214 on init
6215 declare polyphonic const %a[3]
6216 end on
6217 )NKSP_CODE",
6218 .expectParseError = true // polyphonic not allowed for array types
6219 });
6220
6221 runScript({
6222 .code = R"NKSP_CODE(
6223 on init
6224 declare polyphonic const %a[3] := ( 1, 2, 3 )
6225 end on
6226 )NKSP_CODE",
6227 .expectParseError = true // polyphonic not allowed for array types
6228 });
6229
6230 runScript({
6231 .code = R"NKSP_CODE(
6232 on init
6233 declare %a[3] := ( 1, max(8,24), 3 )
6234 exit( %a[0] + %a[1] + %a[2] )
6235 end on
6236 )NKSP_CODE",
6237 .expectIntExitResult = ( 1 + 24 + 3 )
6238 });
6239
6240 runScript({
6241 .code = R"NKSP_CODE(
6242 on init
6243 declare %a[3] := ( 1, abort($NI_CALLBACK_ID), 3 )
6244 end on
6245 )NKSP_CODE",
6246 .expectParseError = true // assigned expression does not result in a value
6247 });
6248
6249 runScript({
6250 .code = R"NKSP_CODE(
6251 on init
6252 declare const %a[3] := ( 1, abort($NI_CALLBACK_ID), 3 )
6253 end on
6254 )NKSP_CODE",
6255 .expectParseError = true // assigned expression does not result in a value
6256 });
6257
6258 runScript({
6259 .code = R"NKSP_CODE(
6260 on init
6261 declare %a[3] := ( 1.0, 2.0, 3.0 )
6262 end on
6263 )NKSP_CODE",
6264 .expectParseError = true // int array declaration vs. real array assignment
6265 });
6266
6267 runScript({
6268 .code = R"NKSP_CODE(
6269 on init
6270 declare %a[3] := ( 1, 2, 3.0 )
6271 end on
6272 )NKSP_CODE",
6273 .expectParseError = true // 3rd element not an integer
6274 });
6275
6276 runScript({
6277 .code = R"NKSP_CODE(
6278 on init
6279 declare %a[3] := ( "x", "y", "z" )
6280 end on
6281 )NKSP_CODE",
6282 .expectParseError = true // int array declaration vs. string array assignment
6283 });
6284
6285 runScript({
6286 .code = R"NKSP_CODE(
6287 on init
6288 declare a[3] := ( 1, 2, 3 )
6289 end on
6290 )NKSP_CODE",
6291 .expectParseError = true // missing type prefix character in variable name
6292 });
6293
6294 runScript({
6295 .code = R"NKSP_CODE(
6296 on init
6297 declare a[3]
6298 end on
6299 )NKSP_CODE",
6300 .expectParseError = true // missing type prefix character in variable name
6301 });
6302
6303 runScript({
6304 .code = R"NKSP_CODE(
6305 on init
6306 declare const %a[3] := ( 1, 2s, 3 )
6307 end on
6308 )NKSP_CODE",
6309 .expectParseError = true // unit types not allowed for arrays
6310 });
6311
6312 runScript({
6313 .code = R"NKSP_CODE(
6314 on init
6315 declare const %a[3] := ( 1, !2, 3 )
6316 end on
6317 )NKSP_CODE",
6318 .expectParseError = true // 'final' not allowed for arrays
6319 });
6320
6321 #if !SILENT_TEST
6322 std::cout << std::endl;
6323 #endif
6324 }
6325
6326 static void testRealVarDeclaration() {
6327 #if !SILENT_TEST
6328 std::cout << "UNIT TEST: real var declaration\n";
6329 #endif
6330
6331 runScript({
6332 .code = R"NKSP_CODE(
6333 on init
6334 declare ~a
6335 exit(~a)
6336 end on
6337 )NKSP_CODE",
6338 .expectRealExitResult = 0.0
6339 });
6340
6341 runScript({
6342 .code = R"NKSP_CODE(
6343 on init
6344 declare ~a := 24.8
6345 exit(~a)
6346 end on
6347 )NKSP_CODE",
6348 .expectRealExitResult = 24.8
6349 });
6350
6351 runScript({
6352 .code = R"NKSP_CODE(
6353 on init
6354 declare ~a := 8.24
6355 ~a := 24.8
6356 exit(~a)
6357 end on
6358 )NKSP_CODE",
6359 .expectRealExitResult = 24.8
6360 });
6361
6362 runScript({
6363 .code = R"NKSP_CODE(
6364 on init
6365 declare ~a
6366 declare ~a
6367 end on
6368 )NKSP_CODE",
6369 .expectParseError = true // variable re-declaration
6370 });
6371
6372 runScript({
6373 .code = R"NKSP_CODE(
6374 on init
6375 declare const ~a
6376 end on
6377 )NKSP_CODE",
6378 .expectParseError = true // const variable declaration without assignment
6379 });
6380
6381 runScript({
6382 .code = R"NKSP_CODE(
6383 on init
6384 declare const ~a := 8.24
6385 exit(~a)
6386 end on
6387 )NKSP_CODE",
6388 .expectRealExitResult = 8.24
6389 });
6390
6391 runScript({
6392 .code = R"NKSP_CODE(
6393 on init
6394 declare const ~a := 28.0
6395 ~a := 8.0
6396 end on
6397 )NKSP_CODE",
6398 .expectParseError = true // attempt to modify const variable
6399 });
6400
6401 runScript({
6402 .code = R"NKSP_CODE(
6403 on init
6404 declare const ~a := 24.8
6405 declare const ~b := ~a
6406 exit(~b)
6407 end on
6408 )NKSP_CODE",
6409 .expectRealExitResult = 24.8
6410 });
6411
6412 runScript({
6413 .code = R"NKSP_CODE(
6414 on init
6415 declare ~a := 24.0
6416 declare const ~b := ~a
6417 end on
6418 )NKSP_CODE",
6419 .expectParseError = true // const variable defined with non-const assignment
6420 });
6421
6422 runScript({
6423 .code = R"NKSP_CODE(
6424 on init
6425 declare polyphonic ~a
6426 exit(~a)
6427 end on
6428 )NKSP_CODE",
6429 .expectRealExitResult = 0.0
6430 });
6431
6432 runScript({
6433 .code = R"NKSP_CODE(
6434 on init
6435 declare const polyphonic ~a
6436 end on
6437 )NKSP_CODE",
6438 .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
6439 });
6440
6441 runScript({
6442 .code = R"NKSP_CODE(
6443 on init
6444 declare polyphonic const ~a
6445 end on
6446 )NKSP_CODE",
6447 .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
6448 });
6449
6450 runScript({
6451 .code = R"NKSP_CODE(
6452 on init
6453 declare const polyphonic ~a := 3.0
6454 end on
6455 )NKSP_CODE",
6456 .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
6457 });
6458
6459 runScript({
6460 .code = R"NKSP_CODE(
6461 on init
6462 declare polyphonic const ~a := 3.0
6463 end on
6464 )NKSP_CODE",
6465 .expectParseError = true // combination of qualifiers 'const' and 'polyphonic' is pointless
6466 });
6467
6468 runScript({
6469 .code = R"NKSP_CODE(
6470 on init
6471 declare $a := 24.8
6472 exit($a)
6473 end on
6474 )NKSP_CODE",
6475 .expectParseWarning = true, // int type declaration vs. real value assignment
6476 .expectRealExitResult = 24.8
6477 });
6478
6479 runScript({
6480 .code = R"NKSP_CODE(
6481 on init
6482 declare %a := 24.8
6483 exit(%a)
6484 end on
6485 )NKSP_CODE",
6486 .expectParseWarning = true, // int array type declaration vs. real scalar value assignment
6487 .expectRealExitResult = 24.8
6488 });
6489
6490 runScript({
6491 .code = R"NKSP_CODE(
6492 on init
6493 declare const %a := 24.8
6494 exit(%a)
6495 end on
6496 )NKSP_CODE",
6497 .expectParseWarning = true, // int array type declaration vs. real scalar value assignment
6498 .expectRealExitResult = 24.8
6499 });
6500
6501 runScript({
6502 .code = R"NKSP_CODE(
6503 on init
6504 declare ?a := 24.8
6505 exit(?a)
6506 end on
6507 )NKSP_CODE",
6508 .expectParseWarning = true, // real array type declaration vs. real scalar value assignment
6509 .expectRealExitResult = 24.8
6510 });
6511
6512 runScript({
6513 .code = R"NKSP_CODE(
6514 on init
6515 declare const ?a := 24.8
6516 exit(?a)
6517 end on
6518 )NKSP_CODE",
6519 .expectParseWarning = true, // real array type declaration vs. real scalar value assignment
6520 .expectRealExitResult = 24.8
6521 });
6522
6523 runScript({
6524 .code = R"NKSP_CODE(
6525 on init
6526 declare @a := 24.8
6527 exit(@a)
6528 end on
6529 )NKSP_CODE",
6530 .expectParseWarning = true, // string type declaration vs. real scalar value assignment
6531 .expectRealExitResult = 24.8
6532 });
6533
6534 runScript({
6535 .code = R"NKSP_CODE(
6536 on init
6537 declare const @a := 24.8
6538 exit(@a)
6539 end on
6540 )NKSP_CODE",
6541 .expectParseWarning = true, // string type declaration vs. real scalar value assignment
6542 .expectRealExitResult = 24.8
6543 });
6544
6545 runScript({
6546 .code = R"NKSP_CODE(
6547 on init
6548 declare ~a := ( 0, 1, 2 )
6549 end on
6550 )NKSP_CODE",
6551 .expectParseError = true // real scalar type declaration vs. int array value assignment
6552 });
6553
6554 runScript({
6555 .code = R"NKSP_CODE(
6556 on init
6557 declare const ~a := ( 0, 1, 2 )
6558 end on
6559 )NKSP_CODE",
6560 .expectParseError = true // real scalar type declaration vs. int array value assignment
6561 });
6562
6563 runScript({
6564 .code = R"NKSP_CODE(
6565 on init
6566 declare a := 24.8
6567 end on
6568 )NKSP_CODE",
6569 .expectParseError = true // missing type prefix character in variable name
6570 });
6571
6572 runScript({
6573 .code = R"NKSP_CODE(
6574 on init
6575 declare const a := 24.8
6576 end on
6577 )NKSP_CODE",
6578 .expectParseError = true // missing type prefix character in variable name
6579 });
6580
6581 runScript({
6582 .code = R"NKSP_CODE(
6583 on init
6584 declare ~a := max(8.1,24.2)
6585 exit(~a)
6586 end on
6587 )NKSP_CODE",
6588 .expectRealExitResult = 24.2
6589 });
6590
6591 runScript({
6592 .code = R"NKSP_CODE(
6593 on init
6594 declare ~a := abort($NI_CALLBACK_ID)
6595 end on
6596 )NKSP_CODE",
6597 .expectParseError = true // assigned expression does not result in a value
6598 });
6599
6600 runScript({
6601 .code = R"NKSP_CODE(
6602 on init
6603 declare const ~a := abort($NI_CALLBACK_ID)
6604 end on
6605 )NKSP_CODE",
6606 .expectParseError = true // assigned expression does not result in a value
6607 });
6608
6609 #if !SILENT_TEST
6610 std::cout << std::endl;
6611 #endif
6612 }
6613
6614 static void testRealArrayVarDeclaration() {
6615 #if !SILENT_TEST
6616 std::cout << "UNIT TEST: real array var declaration\n";
6617 #endif
6618
6619 runScript({
6620 .code = R"NKSP_CODE(
6621 on init
6622 declare ?a[3]
6623 exit( ?a[0] + ?a[1] + ?a[2] )
6624 end on
6625 )NKSP_CODE",
6626 .expectRealExitResult = 0.0
6627 });
6628
6629 runScript({
6630 .code = R"NKSP_CODE(
6631 on init
6632 declare ?a[0]
6633 end on
6634 )NKSP_CODE",
6635 .expectParseWarning = true // unusable array size
6636 });
6637
6638 runScript({
6639 .code = R"NKSP_CODE(
6640 on init
6641 declare ?a[-1]
6642 end on
6643 )NKSP_CODE",
6644 .expectParseError = true // illegal array size
6645 });
6646
6647 runScript({
6648 .code = R"NKSP_CODE(
6649 on init
6650 declare ?a[3] := ( 1.1, 2.2, 3.3 )
6651 exit( ?a[0] + ?a[1] + ?a[2] )
6652 end on
6653 )NKSP_CODE",
6654 .expectRealExitResult = (1.1 + 2.2 + 3.3)
6655 });
6656
6657 runScript({
6658 .code = R"NKSP_CODE(
6659 on init
6660 declare ?a[4] := ( 1.1, 2.2, 3.3 )
6661 exit( ?a[0] + ?a[1] + ?a[2] + ?a[3] )
6662 end on
6663 )NKSP_CODE",
6664 .expectParseWarning = true, // less values assigned than array size declared
6665 .expectRealExitResult = (1.1 + 2.2 + 3.3 + 0.0)
6666 });
6667
6668 runScript({
6669 .code = R"NKSP_CODE(
6670 on init
6671 declare ?a[] := ( 1.1, 2.2, 3.3 )
6672 exit( ?a[0] + ?a[1] + ?a[2] )
6673 end on
6674 )NKSP_CODE",
6675 .expectRealExitResult = (1.1 + 2.2 + 3.3)
6676 });
6677
6678 runScript({
6679 .code = R"NKSP_CODE(
6680 on init
6681 declare ?a[]
6682 end on
6683 )NKSP_CODE",
6684 .expectParseWarning = true // unusable array size (zero)
6685 });
6686
6687 runScript({
6688 .code = R"NKSP_CODE(
6689 on init
6690 declare const $sz := 3
6691 declare ?a[$sz] := ( 1.1, 2.2, 3.3 )
6692 exit( ?a[0] + ?a[1] + ?a[2] )
6693 end on
6694 )NKSP_CODE",
6695 .expectRealExitResult = (1.1 + 2.2 + 3.3)
6696 });
6697
6698 runScript({
6699 .code = R"NKSP_CODE(
6700 on init
6701 declare const $sz := 3
6702 declare const ?a[$sz] := ( 1.1, 2.2, 3.3 )
6703 exit( ?a[0] + ?a[1] + ?a[2] )
6704 end on
6705 )NKSP_CODE",
6706 .expectRealExitResult = (1.1 + 2.2 + 3.3)
6707 });
6708
6709 runScript({
6710 .code = R"NKSP_CODE(
6711 on init
6712 declare $sz := 3
6713 declare ?a[$sz] := ( 1.1, 2.2, 3.3 )
6714 end on
6715 )NKSP_CODE",
6716 .expectParseError = true // array size must be constant expression
6717 });
6718
6719 runScript({
6720 .code = R"NKSP_CODE(
6721 on init
6722 declare $sz := 3
6723 declare const ?a[$sz] := ( 1.1, 2.2, 3.3 )
6724 end on
6725 )NKSP_CODE",
6726 .expectParseError = true // array size must be constant expression
6727 });
6728
6729 runScript({
6730 .code = R"NKSP_CODE(
6731 on init
6732 declare const ~sz := 3.0
6733 declare const ?a[~sz] := ( 1.1, 2.2, 3.3 )
6734 end on
6735 )NKSP_CODE",
6736 .expectParseError = true // array size must be integer type
6737 });
6738
6739 runScript({
6740 .code = R"NKSP_CODE(
6741 on init
6742 declare ?a[3s] := ( 1.1, 2.2, 3.3 )
6743 end on
6744 )NKSP_CODE",
6745 .expectParseError = true // units not allowed for array size
6746 });
6747
6748 runScript({
6749 .code = R"NKSP_CODE(
6750 on init
6751 declare ?a[3m] := ( 1.1, 2.2, 3.3 )
6752 end on
6753 )NKSP_CODE",
6754 .expectParseError = true // units not allowed for array size
6755 });
6756
6757 runScript({
6758 .code = R"NKSP_CODE(
6759 on init
6760 declare const ?a[!3] := ( 1.1, 2.2, 3.3 )
6761 exit( ?a[0] + ?a[1] + ?a[2] )
6762 end on
6763 )NKSP_CODE",
6764 .expectRealExitResult = (1.1 + 2.2 + 3.3),
6765 .expectParseWarning = true // 'final' operator is meaningless for array size
6766 });
6767
6768 runScript({
6769 .code = R"NKSP_CODE(
6770 on init
6771 declare ?a[3] := ( 1.0, 2.0, 3.0 )
6772 ?a[0] := 4.5
6773 ?a[1] := 5.5
6774 ?a[2] := 6.5
6775 exit( ?a[0] + ?a[1] + ?a[2] )
6776 end on
6777 )NKSP_CODE",
6778 .expectRealExitResult = (4.5 + 5.5 + 6.5)
6779 });
6780
6781 runScript({
6782 .code = R"NKSP_CODE(
6783 on init
6784 declare ?a[3]
6785 declare ?a[3]
6786 end on
6787 )NKSP_CODE",
6788 .expectParseError = true // variable re-declaration
6789 });
6790
6791 runScript({
6792 .code = R"NKSP_CODE(
6793 on init
6794 declare const ?a[3]
6795 end on
6796 )NKSP_CODE",
6797 .expectParseError = true // const variable declaration without assignment
6798 });
6799
6800 runScript({
6801 .code = R"NKSP_CODE(
6802 on init
6803 declare const ?a[3] := ( 1.1, 2.2, 3.3 )
6804 exit( ?a[0] + ?a[1] + ?a[2] )
6805 end on
6806 )NKSP_CODE",
6807 .expectRealExitResult = (1.1 + 2.2 + 3.3)
6808 });
6809
6810 runScript({
6811 .code = R"NKSP_CODE(
6812 on init
6813 declare const ?a[3] := ( 1.1, 2.2, 3.3, 4.4 )
6814 end on
6815 )NKSP_CODE",
6816 .expectParseError = true // incompatible array sizes
6817 });
6818
6819 runScript({
6820 .code = R"NKSP_CODE(
6821 on init
6822 declare const ?a[3] := ( 1.0, 2.0, 3.0 )
6823 ?a[0] := 8.0
6824 end on
6825 )NKSP_CODE",
6826 .expectParseError = true // attempt to modify const variable
6827 });
6828
6829 runScript({
6830 .code = R"NKSP_CODE(
6831 on init
6832 declare const ?a[3] := ( 1.1, 2.2, 3.3 )
6833 declare const ?b[3] := ( ?a[0], ?a[1], ?a[2] )
6834 exit( ?b[0] + ?b[1] + ?b[2] )
6835 end on
6836 )NKSP_CODE",
6837 .expectRealExitResult = (1.1 + 2.2 + 3.3)
6838 });
6839
6840 runScript({
6841 .code = R"NKSP_CODE(
6842 on init
6843 declare ?a[3] := ( 1.1, 2.2, 3.3 )
6844 declare const ?b[3] := ( ?a[0], ?a[1], ?a[2] )
6845 end on
6846 )NKSP_CODE",
6847 .expectParseError = true // const array defined with non-const assignment
6848 });
6849
6850 runScript({
6851 .code = R"NKSP_CODE(
6852 on init
6853 declare polyphonic ?a[3]
6854 end on
6855 )NKSP_CODE",
6856 .expectParseError = true // polyphonic not allowed for array types
6857 });
6858
6859 runScript({
6860 .code = R"NKSP_CODE(
6861 on init
6862 declare polyphonic ?a[3] := ( 1.0, 2.0, 3.0 )
6863 end on
6864 )NKSP_CODE",
6865 .expectParseError = true // polyphonic not allowed for array types
6866 });
6867
6868 runScript({
6869 .code = R"NKSP_CODE(
6870 on init
6871 declare const polyphonic ?a[3]
6872 end on
6873 )NKSP_CODE",
6874 .expectParseError = true // polyphonic not allowed for array types
6875 });
6876
6877 runScript({
6878 .code = R"NKSP_CODE(
6879 on init
6880 declare const polyphonic ?a[3] := ( 1.0, 2.0, 3.0 )
6881 end on
6882 )NKSP_CODE",
6883 .expectParseError = true // polyphonic not allowed for array types
6884 });
6885
6886 runScript({
6887 .code = R"NKSP_CODE(
6888 on init
6889 declare polyphonic const ?a[3]
6890 end on
6891 )NKSP_CODE",
6892 .expectParseError = true // polyphonic not allowed for array types
6893 });
6894
6895 runScript({
6896 .code = R"NKSP_CODE(
6897 on init
6898 declare polyphonic const ?a[3] := ( 1.0, 2.0, 3.0 )
6899 end on
6900 )NKSP_CODE",
6901 .expectParseError = true // polyphonic not allowed for array types
6902 });
6903
6904 runScript({
6905 .code = R"NKSP_CODE(
6906 on init
6907 declare ?a[3] := ( 1.0, max(8.3,24.6), 3.0 )
6908 exit( ?a[0] + ?a[1] + ?a[2] )
6909 end on
6910 )NKSP_CODE",
6911 .expectRealExitResult = ( 1.0 + 24.6 + 3.0 )
6912 });
6913
6914 runScript({
6915 .code = R"NKSP_CODE(
6916 on init
6917 declare ?a[3] := ( 1.0, abort($NI_CALLBACK_ID), 3.0 )
6918 end on
6919 )NKSP_CODE",
6920 .expectParseError = true // assigned expression does not result in a value
6921 });
6922
6923 runScript({
6924 .code = R"NKSP_CODE(
6925 on init
6926 declare const ?a[3] := ( 1.0, abort($NI_CALLBACK_ID), 3.0 )
6927 end on
6928 )NKSP_CODE",
6929 .expectParseError = true // assigned expression does not result in a value
6930 });
6931
6932 runScript({
6933 .code = R"NKSP_CODE(
6934 on init
6935 declare ?a[3] := ( 1, 2, 3 )
6936 end on
6937 )NKSP_CODE",
6938 .expectParseError = true // real array declaration vs. int array assignment
6939 });
6940
6941 runScript({
6942 .code = R"NKSP_CODE(
6943 on init
6944 declare ?a[3] := ( 1.0, 2.0, 3 )
6945 end on
6946 )NKSP_CODE",
6947 .expectParseError = true // 3rd element not a real value
6948 });
6949
6950 runScript({
6951 .code = R"NKSP_CODE(
6952 on init
6953 declare ?a[3] := ( "x", "y", "z" )
6954 end on
6955 )NKSP_CODE",
6956 .expectParseError = true // real array declaration vs. string array assignment
6957 });
6958
6959 runScript({
6960 .code = R"NKSP_CODE(
6961 on init
6962 declare a[3] := ( 1.0, 2.0, 3.0 )
6963 end on
6964 )NKSP_CODE",
6965 .expectParseError = true // missing type prefix character in variable name
6966 });
6967
6968 runScript({
6969 .code = R"NKSP_CODE(
6970 on init
6971 declare const ?a[3] := ( 1.0, 2.0s, 3.0 )
6972 end on
6973 )NKSP_CODE",
6974 .expectParseError = true // unit types not allowed for arrays
6975 });
6976
6977 runScript({
6978 .code = R"NKSP_CODE(
6979 on init
6980 declare const ?a[3] := ( 1.0, !2.0, 3.0 )
6981 end on
6982 )NKSP_CODE",
6983 .expectParseError = true // 'final' not allowed for arrays
6984 });
6985
6986 #if !SILENT_TEST
6987 std::cout << std::endl;
6988 #endif
6989 }
6990
6991 static void testStringVarDeclaration() {
6992 #if !SILENT_TEST
6993 std::cout << "UNIT TEST: string var declaration\n";
6994 #endif
6995
6996 runScript({
6997 .code = R"NKSP_CODE(
6998 on init
6999 declare @a
7000 exit(@a)
7001 end on
7002 )NKSP_CODE",
7003 .expectStringExitResult = ""
7004 });
7005
7006 runScript({
7007 .code = R"NKSP_CODE(
7008 on init
7009 declare @a := "foo"
7010 exit(@a)
7011 end on
7012 )NKSP_CODE",
7013 .expectStringExitResult = "foo"
7014 });
7015
7016 runScript({
7017 .code = R"NKSP_CODE(
7018 on init
7019 declare @a := "foo"
7020 @a := "bar"
7021 exit(@a)
7022 end on
7023 )NKSP_CODE",
7024 .expectStringExitResult = "bar"
7025 });
7026
7027 runScript({
7028 .code = R"NKSP_CODE(
7029 on init
7030 declare @a
7031 declare @a
7032 end on
7033 )NKSP_CODE",
7034 .expectParseError = true // variable re-declaration
7035 });
7036
7037 runScript({
7038 .code = R"NKSP_CODE(
7039 on init
7040 declare const @a
7041 end on
7042 )NKSP_CODE",
7043 .expectParseError = true // const variable declaration without assignment
7044 });
7045
7046 runScript({
7047 .code = R"NKSP_CODE(
7048 on init
7049 declare const @a := "foo"
7050 exit(@a)
7051 end on
7052 )NKSP_CODE",
7053 .expectStringExitResult = "foo"
7054 });
7055
7056 runScript({
7057 .code = R"NKSP_CODE(
7058 on init
7059 declare const @a := "foo"
7060 @a := "bar"
7061 end on
7062 )NKSP_CODE",
7063 .expectParseError = true // attempt to modify const variable
7064 });
7065
7066 runScript({
7067 .code = R"NKSP_CODE(
7068 on init
7069 declare const @a := "foo"
7070 declare const @b := @a
7071 exit(@b)
7072 end on
7073 )NKSP_CODE",
7074 .expectStringExitResult = "foo"
7075 });
7076
7077 runScript({
7078 .code = R"NKSP_CODE(
7079 on init
7080 declare @a := "foo"
7081 declare const @b := @a
7082 end on
7083 )NKSP_CODE",
7084 .expectParseError = true // const variable defined with non-const assignment
7085 });
7086
7087 runScript({
7088 .code = R"NKSP_CODE(
7089 on init
7090 declare polyphonic @a
7091 end on
7092 )NKSP_CODE",
7093 .expectParseError = true // 'polyphonic' not allowed for string type
7094 });
7095
7096 runScript({
7097 .code = R"NKSP_CODE(
7098 on init
7099 declare const polyphonic @a
7100 end on
7101 )NKSP_CODE",
7102 .expectParseError = true // 'polyphonic' not allowed for string type
7103 });
7104
7105 runScript({
7106 .code = R"NKSP_CODE(
7107 on init
7108 declare polyphonic const @a
7109 end on
7110 )NKSP_CODE",
7111 .expectParseError = true // 'polyphonic' not allowed for string type
7112 });
7113
7114 runScript({
7115 .code = R"NKSP_CODE(
7116 on init
7117 declare polyphonic @a = "foo"
7118 end on
7119 )NKSP_CODE",
7120 .expectParseError = true // 'polyphonic' not allowed for string type
7121 });
7122
7123 runScript({
7124 .code = R"NKSP_CODE(
7125 on init
7126 declare polyphonic const @a = "foo"
7127 end on
7128 )NKSP_CODE",
7129 .expectParseError = true // 'polyphonic' not allowed for string type
7130 });
7131
7132 runScript({
7133 .code = R"NKSP_CODE(
7134 on init
7135 declare const polyphonic @a = "foo"
7136 end on
7137 )NKSP_CODE",
7138 .expectParseError = true // 'polyphonic' not allowed for string type
7139 });
7140
7141 runScript({
7142 .code = R"NKSP_CODE(
7143 on init
7144 declare $a := "foo"
7145 exit($a)
7146 end on
7147 )NKSP_CODE",
7148 .expectParseWarning = true, // int type declaration vs. string assignment
7149 .expectStringExitResult = "foo"
7150 });
7151
7152 runScript({
7153 .code = R"NKSP_CODE(
7154 on init
7155 declare ~a := "foo"
7156 exit(~a)
7157 end on
7158 )NKSP_CODE",
7159 .expectParseWarning = true, // real type declaration vs. string assignment
7160 .expectStringExitResult = "foo"
7161 });
7162
7163 runScript({
7164 .code = R"NKSP_CODE(
7165 on init
7166 declare %a := "foo"
7167 exit(%a)
7168 end on
7169 )NKSP_CODE",
7170 .expectParseWarning = true, // int array type declaration vs. string assignment
7171 .expectStringExitResult = "foo"
7172 });
7173
7174 runScript({
7175 .code = R"NKSP_CODE(
7176 on init
7177 declare const $a := "foo"
7178 exit($a)
7179 end on
7180 )NKSP_CODE",
7181 .expectParseWarning = true, // int type declaration vs. string assignment
7182 .expectStringExitResult = "foo"
7183 });
7184
7185 runScript({
7186 .code = R"NKSP_CODE(
7187 on init
7188 declare const ~a := "foo"
7189 exit(~a)
7190 end on
7191 )NKSP_CODE",
7192 .expectParseWarning = true, // real type declaration vs. string assignment
7193 .expectStringExitResult = "foo"
7194 });
7195
7196 runScript({
7197 .code = R"NKSP_CODE(
7198 on init
7199 declare const %a := "foo"
7200 exit(%a)
7201 end on
7202 )NKSP_CODE",
7203 .expectParseWarning = true, // int array type declaration vs. string assignment
7204 .expectStringExitResult = "foo"
7205 });
7206
7207 runScript({
7208 .code = R"NKSP_CODE(
7209 on init
7210 declare a := "foo"
7211 end on
7212 )NKSP_CODE",
7213 .expectParseError = true // missing type prefix character in variable name
7214 });
7215
7216 runScript({
7217 .code = R"NKSP_CODE(
7218 on init
7219 declare const a := "foo"
7220 end on
7221 )NKSP_CODE",
7222 .expectParseError = true // missing type prefix character in variable name
7223 });
7224
7225 runScript({
7226 .code = R"NKSP_CODE(
7227 on init
7228 declare @a := abort($NI_CALLBACK_ID)
7229 end on
7230 )NKSP_CODE",
7231 .expectParseError = true // assigned expression does not result in a value
7232 });
7233
7234 runScript({
7235 .code = R"NKSP_CODE(
7236 on init
7237 declare const @a := abort($NI_CALLBACK_ID)
7238 end on
7239 )NKSP_CODE",
7240 .expectParseError = true // assigned expression does not result in a value
7241 });
7242
7243 #if !SILENT_TEST
7244 std::cout << std::endl;
7245 #endif
7246 }
7247
7248 static void testBuiltInMinFunction() {
7249 #if !SILENT_TEST
7250 std::cout << "UNIT TEST: built-in min() function\n";
7251 #endif
7252
7253 runScript({
7254 .code = R"NKSP_CODE(
7255 on init
7256 declare $foo := min
7257 end on
7258 )NKSP_CODE",
7259 .expectParseError = true // because min() function requires 2 arguments
7260 });
7261
7262 runScript({
7263 .code = R"NKSP_CODE(
7264 on init
7265 declare $foo := min()
7266 end on
7267 )NKSP_CODE",
7268 .expectParseError = true // because min() function requires 2 arguments
7269 });
7270
7271 runScript({
7272 .code = R"NKSP_CODE(
7273 on init
7274 declare $foo := min(1)
7275 end on
7276 )NKSP_CODE",
7277 .expectParseError = true // because min() function requires 2 arguments
7278 });
7279
7280 // integer tests ...
7281
7282 runScript({
7283 .code = R"NKSP_CODE(
7284 on init
7285 declare $foo := min(1,2)
7286 exit($foo)
7287 end on
7288 )NKSP_CODE",
7289 .expectIntExitResult = 1
7290 });
7291
7292 runScript({
7293 .code = R"NKSP_CODE(
7294 on init
7295 declare $foo := min(-30,4)
7296 exit($foo)
7297 end on
7298 )NKSP_CODE",
7299 .expectIntExitResult = -30
7300 });
7301
7302 // real number tests ...
7303
7304 runScript({
7305 .code = R"NKSP_CODE(
7306 on init
7307 declare ~foo := min(1.0, 2.0)
7308 exit(~foo)
7309 end on
7310 )NKSP_CODE",
7311 .expectRealExitResult = 1.0
7312 });
7313
7314 runScript({
7315 .code = R"NKSP_CODE(
7316 on init
7317 declare ~foo := min(-30.0, 4.0)
7318 exit(~foo)
7319 end on
7320 )NKSP_CODE",
7321 .expectRealExitResult = -30.0
7322 });
7323
7324 runScript({
7325 .code = R"NKSP_CODE(
7326 on init
7327 declare ~foo := min(1.1, 1.13)
7328 exit(~foo)
7329 end on
7330 )NKSP_CODE",
7331 .expectRealExitResult = 1.1
7332 });
7333
7334 runScript({
7335 .code = R"NKSP_CODE(
7336 on init
7337 declare ~foo := min(1.13, 1.1)
7338 exit(~foo)
7339 end on
7340 )NKSP_CODE",
7341 .expectRealExitResult = 1.1
7342 });
7343
7344 // mixed type tests ...
7345
7346 runScript({
7347 .code = R"NKSP_CODE(
7348 on init
7349 declare ~foo := min(1, 1.16)
7350 exit(~foo)
7351 end on
7352 )NKSP_CODE",
7353 .expectRealExitResult = 1.0,
7354 .expectParseWarning = true // min() warns if data types of arguments not matching
7355 });
7356
7357 runScript({
7358 .code = R"NKSP_CODE(
7359 on init
7360 declare ~foo := min(-3.92, 9)
7361 exit(~foo)
7362 end on
7363 )NKSP_CODE",
7364 .expectRealExitResult = -3.92,
7365 .expectParseWarning = true // min() warns if data types of arguments not matching
7366 });
7367
7368 // std unit tests ...
7369
7370 runScript({
7371 .code = R"NKSP_CODE(
7372 on init
7373 declare $foo := min(30ms,4s)
7374 exit($foo)
7375 end on
7376 )NKSP_CODE",
7377 .expectIntExitResult = 30,
7378 .expectExitResultUnitPrefix = { VM_MILLI },
7379 .expectExitResultUnit = VM_SECOND,
7380 });
7381
7382 runScript({
7383 .code = R"NKSP_CODE(
7384 on init
7385 declare $foo := min(4s,30ms)
7386 exit($foo)
7387 end on
7388 )NKSP_CODE",
7389 .expectIntExitResult = 30,
7390 .expectExitResultUnitPrefix = { VM_MILLI },
7391 .expectExitResultUnit = VM_SECOND,
7392 });
7393
7394 runScript({
7395 .code = R"NKSP_CODE(
7396 on init
7397 declare $foo := min(-30mdB,-4dB)
7398 exit($foo)
7399 end on
7400 )NKSP_CODE",
7401 .expectIntExitResult = -4,
7402 .expectExitResultUnitPrefix = { VM_DECI },
7403 .expectExitResultUnit = VM_BEL,
7404 });
7405
7406 runScript({
7407 .code = R"NKSP_CODE(
7408 on init
7409 declare $foo := min(-4dB,-30mdB)
7410 exit($foo)
7411 end on
7412 )NKSP_CODE",
7413 .expectIntExitResult = -4,
7414 .expectExitResultUnitPrefix = { VM_DECI },
7415 .expectExitResultUnit = VM_BEL,
7416 });
7417
7418 runScript({
7419 .code = R"NKSP_CODE(
7420 on init
7421 declare $foo := min(-4s,-30Hz)
7422 exit($foo)
7423 end on
7424 )NKSP_CODE",
7425 .expectParseError = true // min() requires arguments to have same unit type
7426 });
7427
7428 runScript({
7429 .code = R"NKSP_CODE(
7430 on init
7431 declare $foo := min(-4s,-30)
7432 exit($foo)
7433 end on
7434 )NKSP_CODE",
7435 .expectParseError = true // min() requires arguments to have same unit type
7436 });
7437
7438 runScript({
7439 .code = R"NKSP_CODE(
7440 on init
7441 declare $foo := min(-4,-30s)
7442 exit($foo)
7443 end on
7444 )NKSP_CODE",
7445 .expectParseError = true // min() requires arguments to have same unit type
7446 });
7447
7448 runScript({
7449 .code = R"NKSP_CODE(
7450 on init
7451 declare ~foo := min(0.9s,1.0s)
7452 exit(~foo)
7453 end on
7454 )NKSP_CODE",
7455 .expectRealExitResult = 0.9,
7456 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
7457 .expectExitResultUnit = VM_SECOND,
7458 });
7459
7460 // 'final' ('!') operator tests ...
7461
7462 runScript({
7463 .code = R"NKSP_CODE(
7464 on init
7465 declare $foo := min(!30,!4)
7466 exit($foo)
7467 end on
7468 )NKSP_CODE",
7469 .expectIntExitResult = 4,
7470 .expectExitResultFinal = true
7471 });
7472
7473 runScript({
7474 .code = R"NKSP_CODE(
7475 on init
7476 declare $foo := min(30,4)
7477 exit($foo)
7478 end on
7479 )NKSP_CODE",
7480 .expectIntExitResult = 4,
7481 .expectExitResultFinal = false
7482 });
7483
7484 runScript({
7485 .code = R"NKSP_CODE(
7486 on init
7487 declare $foo := min(30,!4)
7488 exit($foo)
7489 end on
7490 )NKSP_CODE",
7491 .expectIntExitResult = 4,
7492 .expectExitResultFinal = true,
7493 .expectParseWarning = true // min() warns if only one argument is 'final'
7494 });
7495
7496 runScript({
7497 .code = R"NKSP_CODE(
7498 on init
7499 declare $foo := min(!30,4)
7500 exit($foo)
7501 end on
7502 )NKSP_CODE",
7503 .expectIntExitResult = 4,
7504 .expectExitResultFinal = true,
7505 .expectParseWarning = true // min() warns if only one argument is 'final'
7506 });
7507
7508 runScript({
7509 .code = R"NKSP_CODE(
7510 on init
7511 declare ~foo := min(!12.1,!12.2)
7512 exit(~foo)
7513 end on
7514 )NKSP_CODE",
7515 .expectRealExitResult = 12.1,
7516 .expectExitResultFinal = true
7517 });
7518
7519 runScript({
7520 .code = R"NKSP_CODE(
7521 on init
7522 declare ~foo := min(12.1,12.2)
7523 exit(~foo)
7524 end on
7525 )NKSP_CODE",
7526 .expectRealExitResult = 12.1,
7527 .expectExitResultFinal = false
7528 });
7529
7530 runScript({
7531 .code = R"NKSP_CODE(
7532 on init
7533 declare ~foo := min(!12.1,12.2)
7534 exit(~foo)
7535 end on
7536 )NKSP_CODE",
7537 .expectRealExitResult = 12.1,
7538 .expectExitResultFinal = true,
7539 .expectParseWarning = true // min() warns if only one argument is 'final'
7540 });
7541
7542 runScript({
7543 .code = R"NKSP_CODE(
7544 on init
7545 declare ~foo := min(12.1,!12.2)
7546 exit(~foo)
7547 end on
7548 )NKSP_CODE",
7549 .expectRealExitResult = 12.1,
7550 .expectExitResultFinal = true,
7551 .expectParseWarning = true // min() warns if only one argument is 'final'
7552 });
7553
7554 #if !SILENT_TEST
7555 std::cout << std::endl;
7556 #endif
7557 }
7558
7559 static void testBuiltInMaxFunction() {
7560 #if !SILENT_TEST
7561 std::cout << "UNIT TEST: built-in max() function\n";
7562 #endif
7563
7564 // integer tests ...
7565
7566 runScript({
7567 .code = R"NKSP_CODE(
7568 on init
7569 declare $foo := max
7570 end on
7571 )NKSP_CODE",
7572 .expectParseError = true // because max() function requires 2 arguments
7573 });
7574
7575 runScript({
7576 .code = R"NKSP_CODE(
7577 on init
7578 declare $foo := max()
7579 end on
7580 )NKSP_CODE",
7581 .expectParseError = true // because max() function requires 2 arguments
7582 });
7583
7584 runScript({
7585 .code = R"NKSP_CODE(
7586 on init
7587 declare $foo := max(1)
7588 end on
7589 )NKSP_CODE",
7590 .expectParseError = true // because max() function requires 2 arguments
7591 });
7592
7593 runScript({
7594 .code = R"NKSP_CODE(
7595 on init
7596 declare $foo := max(1,2)
7597 exit($foo)
7598 end on
7599 )NKSP_CODE",
7600 .expectIntExitResult = 2
7601 });
7602
7603 runScript({
7604 .code = R"NKSP_CODE(
7605 on init
7606 declare $foo := max(-30,4)
7607 exit($foo)
7608 end on
7609 )NKSP_CODE",
7610 .expectIntExitResult = 4
7611 });
7612
7613 // real number tests ...
7614
7615 runScript({
7616 .code = R"NKSP_CODE(
7617 on init
7618 declare ~foo := max(1.0, 2.0)
7619 exit(~foo)
7620 end on
7621 )NKSP_CODE",
7622 .expectRealExitResult = 2.0
7623 });
7624
7625 runScript({
7626 .code = R"NKSP_CODE(
7627 on init
7628 declare ~foo := max(-30.0, 4.0)
7629 exit(~foo)
7630 end on
7631 )NKSP_CODE",
7632 .expectRealExitResult = 4.0
7633 });
7634
7635 runScript({
7636 .code = R"NKSP_CODE(
7637 on init
7638 declare ~foo := max(1.1, 1.13)
7639 exit(~foo)
7640 end on
7641 )NKSP_CODE",
7642 .expectRealExitResult = 1.13
7643 });
7644
7645 runScript({
7646 .code = R"NKSP_CODE(
7647 on init
7648 declare ~foo := max(1.13, 1.1)
7649 exit(~foo)
7650 end on
7651 )NKSP_CODE",
7652 .expectRealExitResult = 1.13
7653 });
7654
7655 // mixed type tests ...
7656
7657 runScript({
7658 .code = R"NKSP_CODE(
7659 on init
7660 declare ~foo := max(1, 1.16)
7661 exit(~foo)
7662 end on
7663 )NKSP_CODE",
7664 .expectRealExitResult = 1.16,
7665 .expectParseWarning = true // max() warns if data types of arguments not matching
7666 });
7667
7668 runScript({
7669 .code = R"NKSP_CODE(
7670 on init
7671 declare ~foo := max(-3.92, 9)
7672 exit(~foo)
7673 end on
7674 )NKSP_CODE",
7675 .expectRealExitResult = 9.0,
7676 .expectParseWarning = true // max() warns if data types of arguments not matching
7677 });
7678
7679 // std unit tests ...
7680
7681 runScript({
7682 .code = R"NKSP_CODE(
7683 on init
7684 declare $foo := max(30ms,4s)
7685 exit($foo)
7686 end on
7687 )NKSP_CODE",
7688 .expectIntExitResult = 4,
7689 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
7690 .expectExitResultUnit = VM_SECOND,
7691 });
7692
7693 runScript({
7694 .code = R"NKSP_CODE(
7695 on init
7696 declare $foo := max(4s,30ms)
7697 exit($foo)
7698 end on
7699 )NKSP_CODE",
7700 .expectIntExitResult = 4,
7701 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
7702 .expectExitResultUnit = VM_SECOND,
7703 });
7704
7705 runScript({
7706 .code = R"NKSP_CODE(
7707 on init
7708 declare $foo := max(-30mdB,-4dB)
7709 exit($foo)
7710 end on
7711 )NKSP_CODE",
7712 .expectIntExitResult = -30,
7713 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
7714 .expectExitResultUnit = VM_BEL,
7715 });
7716
7717 runScript({
7718 .code = R"NKSP_CODE(
7719 on init
7720 declare $foo := max(-4dB,-30mdB)
7721 exit($foo)
7722 end on
7723 )NKSP_CODE",
7724 .expectIntExitResult = -30,
7725 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
7726 .expectExitResultUnit = VM_BEL,
7727 });
7728
7729 runScript({
7730 .code = R"NKSP_CODE(
7731 on init
7732 declare $foo := max(-4s,-30Hz)
7733 exit($foo)
7734 end on
7735 )NKSP_CODE",
7736 .expectParseError = true // max() requires arguments to have same unit type
7737 });
7738
7739 runScript({
7740 .code = R"NKSP_CODE(
7741 on init
7742 declare $foo := max(-4s,-30)
7743 exit($foo)
7744 end on
7745 )NKSP_CODE",
7746 .expectParseError = true // max() requires arguments to have same unit type
7747 });
7748
7749 runScript({
7750 .code = R"NKSP_CODE(
7751 on init
7752 declare $foo := max(-4,-30s)
7753 exit($foo)
7754 end on
7755 )NKSP_CODE",
7756 .expectParseError = true // max() requires arguments to have same unit type
7757 });
7758
7759 runScript({
7760 .code = R"NKSP_CODE(
7761 on init
7762 declare ~foo := max(0.9s,1.0s)
7763 exit(~foo)
7764 end on
7765 )NKSP_CODE",
7766 .expectRealExitResult = 1.0,
7767 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
7768 .expectExitResultUnit = VM_SECOND,
7769 });
7770
7771 // 'final' ('!') operator tests ...
7772
7773 runScript({
7774 .code = R"NKSP_CODE(
7775 on init
7776 declare $foo := max(!30,!4)
7777 exit($foo)
7778 end on
7779 )NKSP_CODE",
7780 .expectIntExitResult = 30,
7781 .expectExitResultFinal = true
7782 });
7783
7784 runScript({
7785 .code = R"NKSP_CODE(
7786 on init
7787 declare $foo := max(30,4)
7788 exit($foo)
7789 end on
7790 )NKSP_CODE",
7791 .expectIntExitResult = 30,
7792 .expectExitResultFinal = false
7793 });
7794
7795 runScript({
7796 .code = R"NKSP_CODE(
7797 on init
7798 declare $foo := max(30,!4)
7799 exit($foo)
7800 end on
7801 )NKSP_CODE",
7802 .expectIntExitResult = 30,
7803 .expectExitResultFinal = true,
7804 .expectParseWarning = true // max() warns if only one argument is 'final'
7805 });
7806
7807 runScript({
7808 .code = R"NKSP_CODE(
7809 on init
7810 declare $foo := max(!30,4)
7811 exit($foo)
7812 end on
7813 )NKSP_CODE",
7814 .expectIntExitResult = 30,
7815 .expectExitResultFinal = true,
7816 .expectParseWarning = true // max() warns if only one argument is 'final'
7817 });
7818
7819 runScript({
7820 .code = R"NKSP_CODE(
7821 on init
7822 declare ~foo := max(!12.1,!12.2)
7823 exit(~foo)
7824 end on
7825 )NKSP_CODE",
7826 .expectRealExitResult = 12.2,
7827 .expectExitResultFinal = true
7828 });
7829
7830 runScript({
7831 .code = R"NKSP_CODE(
7832 on init
7833 declare ~foo := max(12.1,12.2)
7834 exit(~foo)
7835 end on
7836 )NKSP_CODE",
7837 .expectRealExitResult = 12.2,
7838 .expectExitResultFinal = false
7839 });
7840
7841 runScript({
7842 .code = R"NKSP_CODE(
7843 on init
7844 declare ~foo := max(!12.1,12.2)
7845 exit(~foo)
7846 end on
7847 )NKSP_CODE",
7848 .expectRealExitResult = 12.2,
7849 .expectExitResultFinal = true,
7850 .expectParseWarning = true // max() warns if only one argument is 'final'
7851 });
7852
7853 runScript({
7854 .code = R"NKSP_CODE(
7855 on init
7856 declare ~foo := max(12.1,!12.2)
7857 exit(~foo)
7858 end on
7859 )NKSP_CODE",
7860 .expectRealExitResult = 12.2,
7861 .expectExitResultFinal = true,
7862 .expectParseWarning = true // max() warns if only one argument is 'final'
7863 });
7864
7865 #if !SILENT_TEST
7866 std::cout << std::endl;
7867 #endif
7868 }
7869
7870 static void testBuiltInAbsFunction() {
7871 #if !SILENT_TEST
7872 std::cout << "UNIT TEST: built-in abs() function\n";
7873 #endif
7874
7875 runScript({
7876 .code = R"NKSP_CODE(
7877 on init
7878 declare $foo := abs
7879 end on
7880 )NKSP_CODE",
7881 .expectParseError = true // because abs() function requires 1 argument
7882 });
7883
7884 runScript({
7885 .code = R"NKSP_CODE(
7886 on init
7887 declare $foo := abs()
7888 end on
7889 )NKSP_CODE",
7890 .expectParseError = true // because abs() function requires 1 argument
7891 });
7892
7893 // integer tests ...
7894
7895 runScript({
7896 .code = R"NKSP_CODE(
7897 on init
7898 declare $foo := abs(23)
7899 exit($foo)
7900 end on
7901 )NKSP_CODE",
7902 .expectIntExitResult = 23
7903 });
7904
7905 runScript({
7906 .code = R"NKSP_CODE(
7907 on init
7908 declare $foo := abs(-23)
7909 exit($foo)
7910 end on
7911 )NKSP_CODE",
7912 .expectIntExitResult = 23
7913 });
7914
7915 // real number tests ...
7916
7917 runScript({
7918 .code = R"NKSP_CODE(
7919 on init
7920 declare ~foo := abs(23.0)
7921 exit(~foo)
7922 end on
7923 )NKSP_CODE",
7924 .expectRealExitResult = 23.0
7925 });
7926
7927 runScript({
7928 .code = R"NKSP_CODE(
7929 on init
7930 declare ~foo := abs(23.11)
7931 exit(~foo)
7932 end on
7933 )NKSP_CODE",
7934 .expectRealExitResult = 23.11
7935 });
7936
7937 runScript({
7938 .code = R"NKSP_CODE(
7939 on init
7940 declare ~foo := abs(-23.11)
7941 exit(~foo)
7942 end on
7943 )NKSP_CODE",
7944 .expectRealExitResult = 23.11
7945 });
7946
7947 runScript({
7948 .code = R"NKSP_CODE(
7949 on init
7950 declare ~bar := -23.11
7951 declare ~foo := abs(~bar)
7952 exit(~foo)
7953 end on
7954 )NKSP_CODE",
7955 .expectRealExitResult = 23.11
7956 });
7957
7958 // std unit tests ...
7959
7960 runScript({
7961 .code = R"NKSP_CODE(
7962 on init
7963 declare $foo := abs(-23kHz)
7964 exit($foo)
7965 end on
7966 )NKSP_CODE",
7967 .expectIntExitResult = 23,
7968 .expectExitResultUnitPrefix = { VM_KILO },
7969 .expectExitResultUnit = VM_HERTZ
7970 });
7971
7972 runScript({
7973 .code = R"NKSP_CODE(
7974 on init
7975 declare ~foo := abs(-23.4kHz)
7976 exit(~foo)
7977 end on
7978 )NKSP_CODE",
7979 .expectRealExitResult = 23.4,
7980 .expectExitResultUnitPrefix = { VM_KILO },
7981 .expectExitResultUnit = VM_HERTZ
7982 });
7983
7984 // 'final' ('!') operator tests ...
7985
7986 runScript({
7987 .code = R"NKSP_CODE(
7988 on init
7989 declare $foo := abs(!-23)
7990 exit($foo)
7991 end on
7992 )NKSP_CODE",
7993 .expectIntExitResult = 23,
7994 .expectExitResultFinal = true
7995 });
7996
7997 runScript({
7998 .code = R"NKSP_CODE(
7999 on init
8000 declare $foo := abs(-23)
8001 exit($foo)
8002 end on
8003 )NKSP_CODE",
8004 .expectIntExitResult = 23,
8005 .expectExitResultFinal = false
8006 });
8007
8008 runScript({
8009 .code = R"NKSP_CODE(
8010 on init
8011 declare ~foo := abs(!-23.2)
8012 exit(~foo)
8013 end on
8014 )NKSP_CODE",
8015 .expectRealExitResult = 23.2,
8016 .expectExitResultFinal = true
8017 });
8018
8019 runScript({
8020 .code = R"NKSP_CODE(
8021 on init
8022 declare ~foo := abs(-23.9)
8023 exit(~foo)
8024 end on
8025 )NKSP_CODE",
8026 .expectRealExitResult = 23.9,
8027 .expectExitResultFinal = false
8028 });
8029
8030 #if !SILENT_TEST
8031 std::cout << std::endl;
8032 #endif
8033 }
8034
8035 static void testBuiltInIncFunction() {
8036 #if !SILENT_TEST
8037 std::cout << "UNIT TEST: built-in inc() function\n";
8038 #endif
8039
8040 // integer tests ...
8041
8042 runScript({
8043 .code = R"NKSP_CODE(
8044 on init
8045 declare $foo := 5
8046 inc($foo)
8047 exit($foo)
8048 end on
8049 )NKSP_CODE",
8050 .expectIntExitResult = 6
8051 });
8052
8053 runScript({
8054 .code = R"NKSP_CODE(
8055 on init
8056 declare $foo := 5
8057 inc($foo)
8058 inc($foo)
8059 inc($foo)
8060 exit($foo)
8061 end on
8062 )NKSP_CODE",
8063 .expectIntExitResult = 8
8064 });
8065
8066 runScript({
8067 .code = R"NKSP_CODE(
8068 on init
8069 declare $foo := 5
8070 inc($foo)
8071 exit( inc($foo) )
8072 end on
8073 )NKSP_CODE",
8074 .expectIntExitResult = 7
8075 });
8076
8077 // std unit tests ...
8078
8079 runScript({
8080 .code = R"NKSP_CODE(
8081 on init
8082 declare $foo := 53mdB
8083 inc($foo)
8084 exit( inc($foo) )
8085 end on
8086 )NKSP_CODE",
8087 .expectIntExitResult = 55,
8088 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
8089 .expectExitResultUnit = VM_BEL,
8090 .expectParseWarning = true // inc() warns if argument has a unit
8091 });
8092
8093 // 'final' ('!') operator tests ...
8094
8095 runScript({
8096 .code = R"NKSP_CODE(
8097 on init
8098 declare $foo := !53
8099 inc($foo)
8100 exit( inc($foo) )
8101 end on
8102 )NKSP_CODE",
8103 .expectIntExitResult = 55,
8104 .expectExitResultFinal = true
8105 });
8106
8107 runScript({
8108 .code = R"NKSP_CODE(
8109 on init
8110 declare $foo := 53
8111 inc($foo)
8112 exit( inc($foo) )
8113 end on
8114 )NKSP_CODE",
8115 .expectIntExitResult = 55,
8116 .expectExitResultFinal = false
8117 });
8118
8119 runScript({
8120 .code = R"NKSP_CODE(
8121 on init
8122 declare $foo := 53
8123 inc($foo)
8124 exit( !inc($foo) )
8125 end on
8126 )NKSP_CODE",
8127 .expectIntExitResult = 55,
8128 .expectExitResultFinal = true
8129 });
8130
8131 #if !SILENT_TEST
8132 std::cout << std::endl;
8133 #endif
8134 }
8135
8136 static void testBuiltInDecFunction() {
8137 #if !SILENT_TEST
8138 std::cout << "UNIT TEST: built-in dec() function\n";
8139 #endif
8140
8141 // integer tests ...
8142
8143 runScript({
8144 .code = R"NKSP_CODE(
8145 on init
8146 declare $foo := 5
8147 dec($foo)
8148 exit($foo)
8149 end on
8150 )NKSP_CODE",
8151 .expectIntExitResult = 4
8152 });
8153
8154 runScript({
8155 .code = R"NKSP_CODE(
8156 on init
8157 declare $foo := 5
8158 dec($foo)
8159 dec($foo)
8160 dec($foo)
8161 exit($foo)
8162 end on
8163 )NKSP_CODE",
8164 .expectIntExitResult = 2
8165 });
8166
8167 runScript({
8168 .code = R"NKSP_CODE(
8169 on init
8170 declare $foo := 5
8171 dec($foo)
8172 exit( dec($foo) )
8173 end on
8174 )NKSP_CODE",
8175 .expectIntExitResult = 3
8176 });
8177
8178 // std unit tests ...
8179
8180 runScript({
8181 .code = R"NKSP_CODE(
8182 on init
8183 declare $foo := 53mdB
8184 dec($foo)
8185 exit( dec($foo) )
8186 end on
8187 )NKSP_CODE",
8188 .expectIntExitResult = 51,
8189 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
8190 .expectExitResultUnit = VM_BEL,
8191 .expectParseWarning = true // dec() warns if argument has a unit
8192 });
8193
8194 // 'final' ('!') operator tests ...
8195
8196 runScript({
8197 .code = R"NKSP_CODE(
8198 on init
8199 declare $foo := !53
8200 dec($foo)
8201 exit( dec($foo) )
8202 end on
8203 )NKSP_CODE",
8204 .expectIntExitResult = 51,
8205 .expectExitResultFinal = true
8206 });
8207
8208 runScript({
8209 .code = R"NKSP_CODE(
8210 on init
8211 declare $foo := 53
8212 dec($foo)
8213 exit( dec($foo) )
8214 end on
8215 )NKSP_CODE",
8216 .expectIntExitResult = 51,
8217 .expectExitResultFinal = false
8218 });
8219
8220 runScript({
8221 .code = R"NKSP_CODE(
8222 on init
8223 declare $foo := 53
8224 dec($foo)
8225 exit( !dec($foo) )
8226 end on
8227 )NKSP_CODE",
8228 .expectIntExitResult = 51,
8229 .expectExitResultFinal = true
8230 });
8231
8232 #if !SILENT_TEST
8233 std::cout << std::endl;
8234 #endif
8235 }
8236
8237 static void testBuiltInInRangeFunction() {
8238 #if !SILENT_TEST
8239 std::cout << "UNIT TEST: built-in in_range() function\n";
8240 #endif
8241
8242 // integer tests ...
8243
8244 runScript({
8245 .code = R"NKSP_CODE(
8246 on init
8247 exit( in_range(1,4,9) )
8248 end on
8249 )NKSP_CODE",
8250 .expectBoolExitResult = false
8251 });
8252
8253 runScript({
8254 .code = R"NKSP_CODE(
8255 on init
8256 exit( in_range(5,4,9) )
8257 end on
8258 )NKSP_CODE",
8259 .expectBoolExitResult = true
8260 });
8261
8262 runScript({
8263 .code = R"NKSP_CODE(
8264 on init
8265 exit( in_range(9,4,9) )
8266 end on
8267 )NKSP_CODE",
8268 .expectBoolExitResult = true
8269 });
8270
8271 runScript({
8272 .code = R"NKSP_CODE(
8273 on init
8274 exit( in_range(10,4,9) )
8275 end on
8276 )NKSP_CODE",
8277 .expectBoolExitResult = false
8278 });
8279
8280 runScript({
8281 .code = R"NKSP_CODE(
8282 on init
8283 exit( in_range(-6,-5,5) )
8284 end on
8285 )NKSP_CODE",
8286 .expectBoolExitResult = false
8287 });
8288
8289 runScript({
8290 .code = R"NKSP_CODE(
8291 on init
8292 exit( in_range(-5,-5,5) )
8293 end on
8294 )NKSP_CODE",
8295 .expectBoolExitResult = true
8296 });
8297
8298 runScript({
8299 .code = R"NKSP_CODE(
8300 on init
8301 exit( in_range(0,-5,5) )
8302 end on
8303 )NKSP_CODE",
8304 .expectBoolExitResult = true
8305 });
8306
8307 runScript({
8308 .code = R"NKSP_CODE(
8309 on init
8310 exit( in_range(5,-5,5) )
8311 end on
8312 )NKSP_CODE",
8313 .expectBoolExitResult = true
8314 });
8315
8316 runScript({
8317 .code = R"NKSP_CODE(
8318 on init
8319 exit( in_range(6,-5,5) )
8320 end on
8321 )NKSP_CODE",
8322 .expectBoolExitResult = false
8323 });
8324
8325 // real number tests ...
8326
8327 runScript({
8328 .code = R"NKSP_CODE(
8329 on init
8330 exit( in_range(12.2,12.1,12.9) )
8331 end on
8332 )NKSP_CODE",
8333 .expectBoolExitResult = true
8334 });
8335
8336 runScript({
8337 .code = R"NKSP_CODE(
8338 on init
8339 exit( in_range(12.2,12.9,12.1) )
8340 end on
8341 )NKSP_CODE",
8342 .expectBoolExitResult = true
8343 });
8344
8345 runScript({
8346 .code = R"NKSP_CODE(
8347 on init
8348 exit( in_range(12.0,12.1,12.9) )
8349 end on
8350 )NKSP_CODE",
8351 .expectBoolExitResult = false
8352 });
8353
8354 runScript({
8355 .code = R"NKSP_CODE(
8356 on init
8357 exit( in_range(12.0,12.9,12.1) )
8358 end on
8359 )NKSP_CODE",
8360 .expectBoolExitResult = false
8361 });
8362
8363 runScript({
8364 .code = R"NKSP_CODE(
8365 on init
8366 exit( in_range(0.0,-0.3,0.3) )
8367 end on
8368 )NKSP_CODE",
8369 .expectBoolExitResult = true
8370 });
8371
8372 runScript({
8373 .code = R"NKSP_CODE(
8374 on init
8375 exit( in_range(-0.34,-0.3,0.3) )
8376 end on
8377 )NKSP_CODE",
8378 .expectBoolExitResult = false
8379 });
8380
8381 runScript({
8382 .code = R"NKSP_CODE(
8383 on init
8384 exit( in_range(0.34,-0.3,0.3) )
8385 end on
8386 )NKSP_CODE",
8387 .expectBoolExitResult = false
8388 });
8389
8390 runScript({
8391 .code = R"NKSP_CODE(
8392 on init
8393 exit( in_range(-0.3,-0.3,0.3) )
8394 end on
8395 )NKSP_CODE",
8396 .expectBoolExitResult = true
8397 });
8398
8399 runScript({
8400 .code = R"NKSP_CODE(
8401 on init
8402 exit( in_range(0.3,-0.3,0.3) )
8403 end on
8404 )NKSP_CODE",
8405 .expectBoolExitResult = true
8406 });
8407
8408 // mixed type tests ...
8409
8410 runScript({
8411 .code = R"NKSP_CODE(
8412 on init
8413 exit( in_range(4.0,-5,5) )
8414 end on
8415 )NKSP_CODE",
8416 .expectBoolExitResult = true,
8417 .expectParseWarning = true // in_range() warns if not all arguments are of same type
8418 });
8419
8420 runScript({
8421 .code = R"NKSP_CODE(
8422 on init
8423 exit( in_range(5,-5,5.0) )
8424 end on
8425 )NKSP_CODE",
8426 .expectBoolExitResult = true,
8427 .expectParseWarning = true // in_range() warns if not all arguments are of same type
8428 });
8429
8430 runScript({
8431 .code = R"NKSP_CODE(
8432 on init
8433 exit( in_range(-5,-5.0,5) )
8434 end on
8435 )NKSP_CODE",
8436 .expectBoolExitResult = true,
8437 .expectParseWarning = true // in_range() warns if not all arguments are of same type
8438 });
8439
8440 // std unit tests ...
8441
8442 runScript({
8443 .code = R"NKSP_CODE(
8444 on init
8445 exit( in_range(4000Hz,3kHz,5kHz) )
8446 end on
8447 )NKSP_CODE",
8448 .expectBoolExitResult = true,
8449 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
8450 .expectExitResultUnit = VM_NO_UNIT
8451 });
8452
8453 runScript({
8454 .code = R"NKSP_CODE(
8455 on init
8456 exit( in_range(5000Hz,3kHz,5kHz) )
8457 end on
8458 )NKSP_CODE",
8459 .expectBoolExitResult = true,
8460 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
8461 .expectExitResultUnit = VM_NO_UNIT
8462 });
8463
8464 runScript({
8465 .code = R"NKSP_CODE(
8466 on init
8467 exit( in_range(5001Hz,3kHz,5kHz) )
8468 end on
8469 )NKSP_CODE",
8470 .expectBoolExitResult = false,
8471 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
8472 .expectExitResultUnit = VM_NO_UNIT
8473 });
8474
8475 runScript({
8476 .code = R"NKSP_CODE(
8477 on init
8478 exit( in_range(3000Hz,3kHz,5kHz) )
8479 end on
8480 )NKSP_CODE",
8481 .expectBoolExitResult = true,
8482 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
8483 .expectExitResultUnit = VM_NO_UNIT
8484 });
8485
8486 runScript({
8487 .code = R"NKSP_CODE(
8488 on init
8489 exit( in_range(2999Hz,3kHz,5kHz) )
8490 end on
8491 )NKSP_CODE",
8492 .expectBoolExitResult = false,
8493 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
8494 .expectExitResultUnit = VM_NO_UNIT
8495 });
8496
8497 runScript({
8498 .code = R"NKSP_CODE(
8499 on init
8500 exit( in_range(0.003s,3000.0us,5ms) )
8501 end on
8502 )NKSP_CODE",
8503 .expectBoolExitResult = true,
8504 .expectParseWarning = true, // in_range() warns if not all arguments are of same type
8505 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
8506 .expectExitResultUnit = VM_NO_UNIT
8507 });
8508
8509 runScript({
8510 .code = R"NKSP_CODE(
8511 on init
8512 exit( in_range(0.005s,3000.0us,5ms) )
8513 end on
8514 )NKSP_CODE",
8515 .expectBoolExitResult = true,
8516 .expectParseWarning = true, // in_range() warns if not all arguments are of same type,
8517 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
8518 .expectExitResultUnit = VM_NO_UNIT
8519 });
8520
8521 runScript({
8522 .code = R"NKSP_CODE(
8523 on init
8524 exit( in_range(0.0051s,3000.0us,5ms) )
8525 end on
8526 )NKSP_CODE",
8527 .expectBoolExitResult = false,
8528 .expectParseWarning = true, // in_range() warns if not all arguments are of same type
8529 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
8530 .expectExitResultUnit = VM_NO_UNIT
8531 });
8532
8533 runScript({
8534 .code = R"NKSP_CODE(
8535 on init
8536 exit( in_range(3s,2Hz,5Hz) )
8537 end on
8538 )NKSP_CODE",
8539 .expectParseError = true // in_range() throws error if not all arguments' unit types equal,
8540 });
8541
8542 runScript({
8543 .code = R"NKSP_CODE(
8544 on init
8545 exit( in_range(3Hz,2s,5Hz) )
8546 end on
8547 )NKSP_CODE",
8548 .expectParseError = true // in_range() throws error if not all arguments' unit types equal
8549 });
8550
8551 runScript({
8552 .code = R"NKSP_CODE(
8553 on init
8554 exit( in_range(3Hz,2Hz,5s) )
8555 end on
8556 )NKSP_CODE",
8557 .expectParseError = true // in_range() throws error if not all arguments' unit types equal
8558 });
8559
8560 // 'final' ('!') operator tests ...
8561 // (result should always be NOT final)
8562
8563 runScript({
8564 .code = R"NKSP_CODE(
8565 on init
8566 exit( in_range(!9,!4,!9) )
8567 end on
8568 )NKSP_CODE",
8569 .expectBoolExitResult = true,
8570 .expectExitResultFinal = false
8571 });
8572
8573 #if !SILENT_TEST
8574 std::cout << std::endl;
8575 #endif
8576 }
8577
8578 static void testBuiltInRandomFunction() {
8579 #if !SILENT_TEST
8580 std::cout << "UNIT TEST: built-in random() function\n";
8581 #endif
8582
8583 // integer tests ...
8584
8585 runScript({
8586 .code = R"NKSP_CODE(
8587 on init
8588 exit( random(-5,5) )
8589 end on
8590 )NKSP_CODE",
8591 .expectExitResultIsInt = true // only check type, exact value is irrelevant here
8592 });
8593
8594 for (int run = 0; run < 20; ++run) {
8595 runScript({
8596 .code = R"NKSP_CODE(
8597 on init
8598 declare $foo := random(-5,5)
8599 exit( in_range($foo,-5,5) )
8600 end on
8601 )NKSP_CODE",
8602 .expectBoolExitResult = true
8603 });
8604 }
8605
8606 // real number tests ...
8607
8608 runScript({
8609 .code = R"NKSP_CODE(
8610 on init
8611 exit( random(-0.5,0.5) )
8612 end on
8613 )NKSP_CODE",
8614 .expectExitResultIsReal = true // only check type, exact value is irrelevant here
8615 });
8616
8617 runScript({
8618 .code = R"NKSP_CODE(
8619 on init
8620 declare ~foo := random(-5.0,5.0)
8621 exit(~foo)
8622 end on
8623 )NKSP_CODE",
8624 .expectExitResultIsReal = true // only check type, exact value is irrelevant here
8625 });
8626
8627 for (int run = 0; run < 20; ++run) {
8628 runScript({
8629 .code = R"NKSP_CODE(
8630 on init
8631 declare ~foo := random(-0.5,0.5)
8632 exit( in_range(~foo,-0.5,0.5) )
8633 end on
8634 )NKSP_CODE",
8635 .expectBoolExitResult = true
8636 });
8637 }
8638
8639 for (int run = 0; run < 20; ++run) {
8640 runScript({
8641 .code = R"NKSP_CODE(
8642 on init
8643 declare ~foo := random(-5.0,12.0)
8644 exit( in_range(~foo,-5.0,12.0) )
8645 end on
8646 )NKSP_CODE",
8647 .expectBoolExitResult = true
8648 });
8649 }
8650
8651 for (int run = 0; run < 20; ++run) {
8652 runScript({
8653 .code = R"NKSP_CODE(
8654 on init
8655 declare ~foo := random(23.3,98.4)
8656 exit( in_range(~foo,23.3,98.4) )
8657 end on
8658 )NKSP_CODE",
8659 .expectBoolExitResult = true
8660 });
8661 }
8662
8663 // std unit tests ...
8664
8665 runScript({
8666 .code = R"NKSP_CODE(
8667 on init
8668 exit( random(-5Hz,5Hz) )
8669 end on
8670 )NKSP_CODE",
8671 .expectExitResultIsInt = true, // only check type, exact value is irrelevant here
8672 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
8673 .expectExitResultUnit = VM_HERTZ
8674 });
8675
8676 for (int run = 0; run < 20; ++run) {
8677 runScript({
8678 .code = R"NKSP_CODE(
8679 on init
8680 declare $foo := random(-5Hz,5Hz)
8681 exit( in_range($foo,-5Hz,5Hz) )
8682 end on
8683 )NKSP_CODE",
8684 .expectBoolExitResult = true
8685 });
8686 }
8687
8688 runScript({
8689 .code = R"NKSP_CODE(
8690 on init
8691 exit( random(5us,1ms) )
8692 end on
8693 )NKSP_CODE",
8694 .expectExitResultIsInt = true, // only check type, exact value is irrelevant here
8695 .expectExitResultUnitPrefix = { VM_MICRO },
8696 .expectExitResultUnit = VM_SECOND
8697 });
8698
8699 for (int run = 0; run < 20; ++run) {
8700 runScript({
8701 .code = R"NKSP_CODE(
8702 on init
8703 declare $foo := random(5us,1ms)
8704 exit( in_range($foo,5us,1ms) )
8705 end on
8706 )NKSP_CODE",
8707 .expectBoolExitResult = true
8708 });
8709 }
8710
8711 runScript({
8712 .code = R"NKSP_CODE(
8713 on init
8714 exit( random(1ms,5000us) )
8715 end on
8716 )NKSP_CODE",
8717 .expectExitResultIsInt = true, // only check type, exact value is irrelevant here
8718 .expectExitResultUnitPrefix = { VM_MICRO },
8719 .expectExitResultUnit = VM_SECOND
8720 });
8721
8722 for (int run = 0; run < 20; ++run) {
8723 runScript({
8724 .code = R"NKSP_CODE(
8725 on init
8726 declare $foo := random(1ms,5000us)
8727 exit( in_range($foo,1ms,5000us) )
8728 end on
8729 )NKSP_CODE",
8730 .expectBoolExitResult = true
8731 });
8732 }
8733
8734 runScript({
8735 .code = R"NKSP_CODE(
8736 on init
8737 exit( random(1kHz,20kHz) )
8738 end on
8739 )NKSP_CODE",
8740 .expectExitResultIsInt = true, // only check type, exact value is irrelevant here
8741 .expectExitResultUnitPrefix = { VM_KILO },
8742 .expectExitResultUnit = VM_HERTZ
8743 });
8744
8745 for (int run = 0; run < 20; ++run) {
8746 runScript({
8747 .code = R"NKSP_CODE(
8748 on init
8749 declare $foo := random(1kHz,20kHz)
8750 exit( in_range($foo,1kHz,20kHz) )
8751 end on
8752 )NKSP_CODE",
8753 .expectBoolExitResult = true
8754 });
8755 }
8756
8757 runScript({
8758 .code = R"NKSP_CODE(
8759 on init
8760 exit( random(1.2us,3.5us) )
8761 end on
8762 )NKSP_CODE",
8763 .expectExitResultIsReal = true, // only check type, exact value is irrelevant here
8764 .expectExitResultUnitPrefix = { VM_MICRO },
8765 .expectExitResultUnit = VM_SECOND
8766 });
8767
8768 for (int run = 0; run < 20; ++run) {
8769 runScript({
8770 .code = R"NKSP_CODE(
8771 on init
8772 declare ~foo := random(1.2us,3.5us)
8773 exit( in_range(~foo,1.2us,3.5us) )
8774 end on
8775 )NKSP_CODE",
8776 .expectBoolExitResult = true
8777 });
8778 }
8779
8780 runScript({
8781 .code = R"NKSP_CODE(
8782 on init
8783 exit( random(5.2us,1.1ms) )
8784 end on
8785 )NKSP_CODE",
8786 .expectExitResultIsReal = true, // only check type, exact value is irrelevant here
8787 .expectExitResultUnitPrefix = { VM_MICRO },
8788 .expectExitResultUnit = VM_SECOND
8789 });
8790
8791 for (int run = 0; run < 20; ++run) {
8792 runScript({
8793 .code = R"NKSP_CODE(
8794 on init
8795 declare ~foo := random(5.2us,1.1ms)
8796 exit( in_range(~foo,5.2us,1.1ms) )
8797 end on
8798 )NKSP_CODE",
8799 .expectBoolExitResult = true
8800 });
8801 }
8802
8803 runScript({
8804 .code = R"NKSP_CODE(
8805 on init
8806 exit( random(1Hz,12s) )
8807 end on
8808 )NKSP_CODE",
8809 .expectParseError = true // random() throws error if arguments' unit types don't match
8810 });
8811
8812 runScript({
8813 .code = R"NKSP_CODE(
8814 on init
8815 exit( random(1,12s) )
8816 end on
8817 )NKSP_CODE",
8818 .expectParseError = true // random() throws error if arguments' unit types don't match
8819 });
8820
8821 runScript({
8822 .code = R"NKSP_CODE(
8823 on init
8824 exit( random(1s,12) )
8825 end on
8826 )NKSP_CODE",
8827 .expectParseError = true // random() throws error if arguments' unit types don't match
8828 });
8829
8830 // 'final' ('!') operator tests ...
8831
8832 runScript({
8833 .code = R"NKSP_CODE(
8834 on init
8835 exit( random(!1,!12) )
8836 end on
8837 )NKSP_CODE",
8838 .expectExitResultFinal = true
8839 });
8840
8841 runScript({
8842 .code = R"NKSP_CODE(
8843 on init
8844 exit( random(1,12) )
8845 end on
8846 )NKSP_CODE",
8847 .expectExitResultFinal = false
8848 });
8849
8850 runScript({
8851 .code = R"NKSP_CODE(
8852 on init
8853 exit( random(!1,12) )
8854 end on
8855 )NKSP_CODE",
8856 .expectExitResultFinal = true,
8857 .expectParseWarning = true // random() warns if only one argument is 'final'
8858 });
8859
8860 runScript({
8861 .code = R"NKSP_CODE(
8862 on init
8863 exit( random(1,!12) )
8864 end on
8865 )NKSP_CODE",
8866 .expectExitResultFinal = true,
8867 .expectParseWarning = true // random() warns if only one argument is 'final'
8868 });
8869
8870 #if !SILENT_TEST
8871 std::cout << std::endl;
8872 #endif
8873 }
8874
8875 static void testBuiltInShiftLeftFunction() {
8876 #if !SILENT_TEST
8877 std::cout << "UNIT TEST: built-in sh_left() function\n";
8878 #endif
8879
8880 runScript({
8881 .code = R"NKSP_CODE(
8882 on init
8883 exit( sh_left(1,0) )
8884 end on
8885 )NKSP_CODE",
8886 .expectIntExitResult = 1
8887 });
8888
8889 runScript({
8890 .code = R"NKSP_CODE(
8891 on init
8892 exit( sh_left(1,1) )
8893 end on
8894 )NKSP_CODE",
8895 .expectIntExitResult = 2
8896 });
8897
8898 runScript({
8899 .code = R"NKSP_CODE(
8900 on init
8901 exit( sh_left(1,2) )
8902 end on
8903 )NKSP_CODE",
8904 .expectIntExitResult = 4
8905 });
8906
8907 runScript({
8908 .code = R"NKSP_CODE(
8909 on init
8910 exit( sh_left(1,3) )
8911 end on
8912 )NKSP_CODE",
8913 .expectIntExitResult = 8
8914 });
8915
8916 #if !SILENT_TEST
8917 std::cout << std::endl;
8918 #endif
8919 }
8920
8921 static void testBuiltInShiftRightFunction() {
8922 #if !SILENT_TEST
8923 std::cout << "UNIT TEST: built-in sh_right() function\n";
8924 #endif
8925
8926 runScript({
8927 .code = R"NKSP_CODE(
8928 on init
8929 exit( sh_right(8,0) )
8930 end on
8931 )NKSP_CODE",
8932 .expectIntExitResult = 8
8933 });
8934
8935 runScript({
8936 .code = R"NKSP_CODE(
8937 on init
8938 exit( sh_right(8,1) )
8939 end on
8940 )NKSP_CODE",
8941 .expectIntExitResult = 4
8942 });
8943
8944 runScript({
8945 .code = R"NKSP_CODE(
8946 on init
8947 exit( sh_right(8,2) )
8948 end on
8949 )NKSP_CODE",
8950 .expectIntExitResult = 2
8951 });
8952
8953 runScript({
8954 .code = R"NKSP_CODE(
8955 on init
8956 exit( sh_right(8,3) )
8957 end on
8958 )NKSP_CODE",
8959 .expectIntExitResult = 1
8960 });
8961
8962 runScript({
8963 .code = R"NKSP_CODE(
8964 on init
8965 exit( sh_right(8,4) )
8966 end on
8967 )NKSP_CODE",
8968 .expectIntExitResult = 0
8969 });
8970
8971 #if !SILENT_TEST
8972 std::cout << std::endl;
8973 #endif
8974 }
8975
8976 static void testBuiltInMsbFunction() {
8977 #if !SILENT_TEST
8978 std::cout << "UNIT TEST: built-in msb() function\n";
8979 #endif
8980
8981 runScript({
8982 .code = R"NKSP_CODE(
8983 on init
8984 exit( msb(0) )
8985 end on
8986 )NKSP_CODE",
8987 .expectIntExitResult = 0
8988 });
8989
8990 runScript({
8991 .code = R"NKSP_CODE(
8992 on init
8993 exit( msb(127) )
8994 end on
8995 )NKSP_CODE",
8996 .expectIntExitResult = 0
8997 });
8998
8999 runScript({
9000 .code = R"NKSP_CODE(
9001 on init
9002 exit( msb(128) )
9003 end on
9004 )NKSP_CODE",
9005 .expectIntExitResult = 1
9006 });
9007
9008 runScript({
9009 .code = R"NKSP_CODE(
9010 on init
9011 exit( msb(16255) )
9012 end on
9013 )NKSP_CODE",
9014 .expectIntExitResult = 126
9015 });
9016
9017 runScript({
9018 .code = R"NKSP_CODE(
9019 on init
9020 exit( msb(16256) )
9021 end on
9022 )NKSP_CODE",
9023 .expectIntExitResult = 127
9024 });
9025
9026 runScript({
9027 .code = R"NKSP_CODE(
9028 on init
9029 exit( msb(16383) )
9030 end on
9031 )NKSP_CODE",
9032 .expectIntExitResult = 127
9033 });
9034
9035 #if !SILENT_TEST
9036 std::cout << std::endl;
9037 #endif
9038 }
9039
9040 static void testBuiltInLsbFunction() {
9041 #if !SILENT_TEST
9042 std::cout << "UNIT TEST: built-in lsb() function\n";
9043 #endif
9044
9045 runScript({
9046 .code = R"NKSP_CODE(
9047 on init
9048 exit( lsb(0) )
9049 end on
9050 )NKSP_CODE",
9051 .expectIntExitResult = 0
9052 });
9053
9054 runScript({
9055 .code = R"NKSP_CODE(
9056 on init
9057 exit( lsb(1) )
9058 end on
9059 )NKSP_CODE",
9060 .expectIntExitResult = 1
9061 });
9062
9063 runScript({
9064 .code = R"NKSP_CODE(
9065 on init
9066 exit( lsb(126) )
9067 end on
9068 )NKSP_CODE",
9069 .expectIntExitResult = 126
9070 });
9071
9072 runScript({
9073 .code = R"NKSP_CODE(
9074 on init
9075 exit( lsb(127) )
9076 end on
9077 )NKSP_CODE",
9078 .expectIntExitResult = 127
9079 });
9080
9081 runScript({
9082 .code = R"NKSP_CODE(
9083 on init
9084 exit( lsb(128) )
9085 end on
9086 )NKSP_CODE",
9087 .expectIntExitResult = 0
9088 });
9089
9090 runScript({
9091 .code = R"NKSP_CODE(
9092 on init
9093 exit( lsb(16255) )
9094 end on
9095 )NKSP_CODE",
9096 .expectIntExitResult = 127
9097 });
9098
9099 runScript({
9100 .code = R"NKSP_CODE(
9101 on init
9102 exit( lsb(16256) )
9103 end on
9104 )NKSP_CODE",
9105 .expectIntExitResult = 0
9106 });
9107
9108 #if !SILENT_TEST
9109 std::cout << std::endl;
9110 #endif
9111 }
9112
9113 static void testBuiltInIntToRealFunction() {
9114 #if !SILENT_TEST
9115 std::cout << "UNIT TEST: built-in int_to_real() function\n";
9116 #endif
9117
9118 runScript({
9119 .code = R"NKSP_CODE(
9120 on init
9121 exit( int_to_real(8) )
9122 end on
9123 )NKSP_CODE",
9124 .expectRealExitResult = 8.0
9125 });
9126
9127 runScript({
9128 .code = R"NKSP_CODE(
9129 on init
9130 declare $foo := 23
9131 exit( int_to_real($foo) )
9132 end on
9133 )NKSP_CODE",
9134 .expectRealExitResult = 23.0
9135 });
9136
9137 // std unit tests ...
9138
9139 runScript({
9140 .code = R"NKSP_CODE(
9141 on init
9142 exit( int_to_real(-58mdB) )
9143 end on
9144 )NKSP_CODE",
9145 .expectRealExitResult = -58.0,
9146 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
9147 .expectExitResultUnit = VM_BEL
9148 });
9149
9150 runScript({
9151 .code = R"NKSP_CODE(
9152 on init
9153 declare $foo := -58mdB
9154 exit( int_to_real($foo) )
9155 end on
9156 )NKSP_CODE",
9157 .expectRealExitResult = -58.0,
9158 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
9159 .expectExitResultUnit = VM_BEL
9160 });
9161
9162 runScript({
9163 .code = R"NKSP_CODE(
9164 on init
9165 declare $foo := 7000ms
9166 exit( int_to_real($foo) )
9167 end on
9168 )NKSP_CODE",
9169 .expectRealExitResult = 7000.0,
9170 .expectExitResultUnitPrefix = { VM_MILLI },
9171 .expectExitResultUnit = VM_SECOND
9172 });
9173
9174 runScript({
9175 .code = R"NKSP_CODE(
9176 on init
9177 declare $foo := 7000ms
9178 declare @s := "" & int_to_real($foo)
9179 exit( @s )
9180 end on
9181 )NKSP_CODE",
9182 .expectStringExitResult = "7000ms",
9183 });
9184
9185 runScript({
9186 .code = R"NKSP_CODE(
9187 on init
9188 declare $foo := 700ms
9189 exit( int_to_real($foo) / 7.0 )
9190 end on
9191 )NKSP_CODE",
9192 .expectRealExitResult = 100.0,
9193 .expectExitResultUnitPrefix = { VM_MILLI },
9194 .expectExitResultUnit = VM_SECOND
9195 });
9196
9197 runScript({
9198 .code = R"NKSP_CODE(
9199 on init
9200 declare $foo := 700ms
9201 exit( int_to_real($foo) / 7.0 & "" )
9202 end on
9203 )NKSP_CODE",
9204 .expectStringExitResult = "100ms"
9205 });
9206
9207 // 'final' ('!') operator tests ...
9208
9209 runScript({
9210 .code = R"NKSP_CODE(
9211 on init
9212 declare $foo := !-58
9213 exit( int_to_real($foo) )
9214 end on
9215 )NKSP_CODE",
9216 .expectRealExitResult = -58.0,
9217 .expectExitResultFinal = true
9218 });
9219
9220 runScript({
9221 .code = R"NKSP_CODE(
9222 on init
9223 declare $foo := -58
9224 exit( int_to_real($foo) )
9225 end on
9226 )NKSP_CODE",
9227 .expectRealExitResult = -58.0,
9228 .expectExitResultFinal = false
9229 });
9230
9231 #if !SILENT_TEST
9232 std::cout << std::endl;
9233 #endif
9234 }
9235
9236 static void testBuiltInRealFunction() {
9237 #if !SILENT_TEST
9238 std::cout << "UNIT TEST: built-in real() function\n";
9239 #endif
9240
9241 runScript({
9242 .code = R"NKSP_CODE(
9243 on init
9244 exit( real(8) )
9245 end on
9246 )NKSP_CODE",
9247 .expectRealExitResult = 8.0
9248 });
9249
9250 runScript({
9251 .code = R"NKSP_CODE(
9252 on init
9253 declare $foo := 23
9254 exit( real($foo) )
9255 end on
9256 )NKSP_CODE",
9257 .expectRealExitResult = 23.0
9258 });
9259
9260 // std unit tests ...
9261
9262 runScript({
9263 .code = R"NKSP_CODE(
9264 on init
9265 exit( real(-58mdB) )
9266 end on
9267 )NKSP_CODE",
9268 .expectRealExitResult = -58.0,
9269 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
9270 .expectExitResultUnit = VM_BEL
9271 });
9272
9273 runScript({
9274 .code = R"NKSP_CODE(
9275 on init
9276 declare $foo := -58mdB
9277 exit( real($foo) )
9278 end on
9279 )NKSP_CODE",
9280 .expectRealExitResult = -58.0,
9281 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
9282 .expectExitResultUnit = VM_BEL
9283 });
9284
9285 runScript({
9286 .code = R"NKSP_CODE(
9287 on init
9288 declare $foo := 7000ms
9289 exit( real($foo) )
9290 end on
9291 )NKSP_CODE",
9292 .expectRealExitResult = 7000.0,
9293 .expectExitResultUnitPrefix = { VM_MILLI },
9294 .expectExitResultUnit = VM_SECOND
9295 });
9296
9297 runScript({
9298 .code = R"NKSP_CODE(
9299 on init
9300 declare $foo := 7000ms
9301 declare @s := "" & real($foo)
9302 exit( @s )
9303 end on
9304 )NKSP_CODE",
9305 .expectStringExitResult = "7000ms",
9306 });
9307
9308 runScript({
9309 .code = R"NKSP_CODE(
9310 on init
9311 declare $foo := 700ms
9312 exit( real($foo) / 7.0 )
9313 end on
9314 )NKSP_CODE",
9315 .expectRealExitResult = 100.0,
9316 .expectExitResultUnitPrefix = { VM_MILLI },
9317 .expectExitResultUnit = VM_SECOND
9318 });
9319
9320 runScript({
9321 .code = R"NKSP_CODE(
9322 on init
9323 declare $foo := 700ms
9324 exit( real($foo) / 7.0 & "" )
9325 end on
9326 )NKSP_CODE",
9327 .expectStringExitResult = "100ms"
9328 });
9329
9330 // 'final' ('!') operator tests ...
9331
9332 runScript({
9333 .code = R"NKSP_CODE(
9334 on init
9335 declare $foo := !-58
9336 exit( real($foo) )
9337 end on
9338 )NKSP_CODE",
9339 .expectRealExitResult = -58.0,
9340 .expectExitResultFinal = true
9341 });
9342
9343 runScript({
9344 .code = R"NKSP_CODE(
9345 on init
9346 declare $foo := -58
9347 exit( real($foo) )
9348 end on
9349 )NKSP_CODE",
9350 .expectRealExitResult = -58.0,
9351 .expectExitResultFinal = false
9352 });
9353
9354 #if !SILENT_TEST
9355 std::cout << std::endl;
9356 #endif
9357 }
9358
9359 static void testBuiltInRealToIntFunction() {
9360 #if !SILENT_TEST
9361 std::cout << "UNIT TEST: built-in real_to_int() function\n";
9362 #endif
9363
9364 runScript({
9365 .code = R"NKSP_CODE(
9366 on init
9367 exit( real_to_int(8.9) )
9368 end on
9369 )NKSP_CODE",
9370 .expectIntExitResult = 8
9371 });
9372
9373 runScript({
9374 .code = R"NKSP_CODE(
9375 on init
9376 declare ~foo := 8.9
9377 exit( real_to_int(~foo) )
9378 end on
9379 )NKSP_CODE",
9380 .expectIntExitResult = 8
9381 });
9382
9383 // std unit tests ...
9384
9385 runScript({
9386 .code = R"NKSP_CODE(
9387 on init
9388 declare ~foo := 8.9mdB
9389 exit( real_to_int(~foo) )
9390 end on
9391 )NKSP_CODE",
9392 .expectIntExitResult = 8,
9393 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
9394 .expectExitResultUnit = VM_BEL
9395 });
9396
9397 runScript({
9398 .code = R"NKSP_CODE(
9399 on init
9400 declare ~foo := 9000.0us
9401 exit( real_to_int(~foo) )
9402 end on
9403 )NKSP_CODE",
9404 .expectIntExitResult = 9000.0,
9405 .expectExitResultUnitPrefix = { VM_MICRO },
9406 .expectExitResultUnit = VM_SECOND
9407 });
9408
9409 runScript({
9410 .code = R"NKSP_CODE(
9411 on init
9412 declare ~foo := 9000.0us
9413 declare @s := "" & real_to_int(~foo)
9414 exit( @s )
9415 end on
9416 )NKSP_CODE",
9417 .expectStringExitResult = "9000us",
9418 });
9419
9420 runScript({
9421 .code = R"NKSP_CODE(
9422 on init
9423 declare ~foo := 700.0ms
9424 exit( real_to_int(~foo) / 7 )
9425 end on
9426 )NKSP_CODE",
9427 .expectIntExitResult = 100,
9428 .expectExitResultUnitPrefix = { VM_MILLI },
9429 .expectExitResultUnit = VM_SECOND
9430 });
9431
9432 runScript({
9433 .code = R"NKSP_CODE(
9434 on init
9435 declare ~foo := 700.0ms
9436 exit( real_to_int(~foo) / 7 & "" )
9437 end on
9438 )NKSP_CODE",
9439 .expectStringExitResult = "100ms"
9440 });
9441
9442 // 'final' ('!') operator tests ...
9443
9444 runScript({
9445 .code = R"NKSP_CODE(
9446 on init
9447 declare ~foo := !8.9
9448 exit( real_to_int(~foo) )
9449 end on
9450 )NKSP_CODE",
9451 .expectIntExitResult = 8,
9452 .expectExitResultFinal = true
9453 });
9454
9455 runScript({
9456 .code = R"NKSP_CODE(
9457 on init
9458 declare ~foo := 8.9
9459 exit( real_to_int(~foo) )
9460 end on
9461 )NKSP_CODE",
9462 .expectIntExitResult = 8,
9463 .expectExitResultFinal = false
9464 });
9465
9466 #if !SILENT_TEST
9467 std::cout << std::endl;
9468 #endif
9469 }
9470
9471 static void testBuiltInIntFunction() {
9472 #if !SILENT_TEST
9473 std::cout << "UNIT TEST: built-in int() function\n";
9474 #endif
9475
9476 runScript({
9477 .code = R"NKSP_CODE(
9478 on init
9479 exit( int(8.9) )
9480 end on
9481 )NKSP_CODE",
9482 .expectIntExitResult = 8
9483 });
9484
9485 runScript({
9486 .code = R"NKSP_CODE(
9487 on init
9488 declare ~foo := 8.9
9489 exit( int(~foo) )
9490 end on
9491 )NKSP_CODE",
9492 .expectIntExitResult = 8
9493 });
9494
9495 // std unit tests ...
9496
9497 runScript({
9498 .code = R"NKSP_CODE(
9499 on init
9500 declare ~foo := 8.9mdB
9501 exit( int(~foo) )
9502 end on
9503 )NKSP_CODE",
9504 .expectIntExitResult = 8,
9505 .expectExitResultUnitPrefix = { VM_MILLI, VM_DECI },
9506 .expectExitResultUnit = VM_BEL
9507 });
9508
9509 runScript({
9510 .code = R"NKSP_CODE(
9511 on init
9512 declare ~foo := 9000.0us
9513 exit( int(~foo) )
9514 end on
9515 )NKSP_CODE",
9516 .expectIntExitResult = 9000.0,
9517 .expectExitResultUnitPrefix = { VM_MICRO },
9518 .expectExitResultUnit = VM_SECOND
9519 });
9520
9521 runScript({
9522 .code = R"NKSP_CODE(
9523 on init
9524 declare ~foo := 9000.0us
9525 declare @s := "" & int(~foo)
9526 exit( @s )
9527 end on
9528 )NKSP_CODE",
9529 .expectStringExitResult = "9000us",
9530 });
9531
9532 runScript({
9533 .code = R"NKSP_CODE(
9534 on init
9535 declare ~foo := 700.0ms
9536 exit( int(~foo) / 7 )
9537 end on
9538 )NKSP_CODE",
9539 .expectIntExitResult = 100,
9540 .expectExitResultUnitPrefix = { VM_MILLI },
9541 .expectExitResultUnit = VM_SECOND
9542 });
9543
9544 runScript({
9545 .code = R"NKSP_CODE(
9546 on init
9547 declare ~foo := 700.0ms
9548 exit( int(~foo) / 7 & "" )
9549 end on
9550 )NKSP_CODE",
9551 .expectStringExitResult = "100ms"
9552 });
9553
9554 // 'final' ('!') operator tests ...
9555
9556 runScript({
9557 .code = R"NKSP_CODE(
9558 on init
9559 declare ~foo := !8.9
9560 exit( int(~foo) )
9561 end on
9562 )NKSP_CODE",
9563 .expectIntExitResult = 8,
9564 .expectExitResultFinal = true
9565 });
9566
9567 runScript({
9568 .code = R"NKSP_CODE(
9569 on init
9570 declare ~foo := 8.9
9571 exit( int(~foo) )
9572 end on
9573 )NKSP_CODE",
9574 .expectIntExitResult = 8,
9575 .expectExitResultFinal = false
9576 });
9577
9578 #if !SILENT_TEST
9579 std::cout << std::endl;
9580 #endif
9581 }
9582
9583 static void testBuiltInArrayEqualFunction() {
9584 #if !SILENT_TEST
9585 std::cout << "UNIT TEST: built-in array_equal() function\n";
9586 #endif
9587
9588 // integer array tests ...
9589
9590 runScript({
9591 .code = R"NKSP_CODE(
9592 on init
9593 declare %foo[3] := ( 1, 2, 3 )
9594 declare %bar[3] := ( 1, 2, 3 )
9595 exit( array_equal(%foo, %bar) )
9596 end on
9597 )NKSP_CODE",
9598 .expectBoolExitResult = true
9599 });
9600
9601 runScript({
9602 .code = R"NKSP_CODE(
9603 on init
9604 declare %foo[1] := ( 1 )
9605 declare %bar[1] := ( 1 )
9606 exit( array_equal(%foo, %bar) )
9607 end on
9608 )NKSP_CODE",
9609 .expectBoolExitResult = true
9610 });
9611
9612 runScript({
9613 .code = R"NKSP_CODE(
9614 on init
9615 declare %foo[3] := ( 1, 2, 3 )
9616 declare %bar[3] := ( 0, 2, 3 )
9617 exit( array_equal(%foo, %bar) )
9618 end on
9619 )NKSP_CODE",
9620 .expectBoolExitResult = false
9621 });
9622
9623 runScript({
9624 .code = R"NKSP_CODE(
9625 on init
9626 declare %foo[3] := ( 1, 2, 3 )
9627 declare %bar[3] := ( 3, 2, 1 )
9628 exit( array_equal(%foo, %bar) )
9629 end on
9630 )NKSP_CODE",
9631 .expectBoolExitResult = false
9632 });
9633
9634 runScript({
9635 .code = R"NKSP_CODE(
9636 on init
9637 declare %foo[3] := ( 1, 2, 3 )
9638 declare %bar[2] := ( 1, 2 )
9639 exit( array_equal(%foo, %bar) )
9640 end on
9641 )NKSP_CODE",
9642 .expectBoolExitResult = false,
9643 .expectParseWarning = true // array_equal() warns if array sizes do not match
9644 });
9645
9646 // real number array tests ...
9647
9648 runScript({
9649 .code = R"NKSP_CODE(
9650 on init
9651 declare ?foo[3] := ( 1.0, 2.0, 3.0 )
9652 declare ?bar[3] := ( 1.0, 2.0, 3.0 )
9653 exit( array_equal(?foo, ?bar) )
9654 end on
9655 )NKSP_CODE",
9656 .expectBoolExitResult = true
9657 });
9658
9659 runScript({
9660 .code = R"NKSP_CODE(
9661 on init
9662 declare ?foo[3] := ( 1.0, 1.1, 3.4 )
9663 declare ?bar[3] := ( 1.0, 1.1, 3.4 )
9664 exit( array_equal(?foo, ?bar) )
9665 end on
9666 )NKSP_CODE",
9667 .expectBoolExitResult = true
9668 });
9669
9670 runScript({
9671 .code = R"NKSP_CODE(
9672 on init
9673 declare ?foo[3] := ( 1.0, 1.1, 3.4 )
9674 declare ?bar[3] := ( 1.0, 1.2, 3.4 )
9675 exit( array_equal(?foo, ?bar) )
9676 end on
9677 )NKSP_CODE",
9678 .expectBoolExitResult = false
9679 });
9680
9681 runScript({
9682 .code = R"NKSP_CODE(
9683 on init
9684 declare ?foo[3] := ( 1.0, 1.1, 3.4 )
9685 declare ?bar[2] := ( 1.0, 1.1 )
9686 exit( array_equal(?foo, ?bar) )
9687 end on
9688 )NKSP_CODE",
9689 .expectBoolExitResult = false,
9690 .expectParseWarning = true // array_equal() warns if array sizes do not match
9691 });
9692
9693 // std unit tests ...
9694 // (only metric prefixes allowed, unit types are prohibited for arrays ATM)
9695
9696 runScript({
9697 .code = R"NKSP_CODE(
9698 on init
9699 declare %foo[3] := ( 1, 1s, 1 )
9700 declare %bar[3] := ( 1, 1, 1 )
9701 exit( array_equal(%foo, %bar) )
9702 end on
9703 )NKSP_CODE",
9704 .expectParseError = true // see comment above
9705 });
9706
9707 runScript({
9708 .code = R"NKSP_CODE(
9709 on init
9710 declare %foo[3] := ( 1k, 1, 1m )
9711 declare %bar[3] := ( 1k, 1, 1m )
9712 exit( array_equal(%foo, %bar) )
9713 end on
9714 )NKSP_CODE",
9715 .expectBoolExitResult = true
9716 });
9717
9718 runScript({
9719 .code = R"NKSP_CODE(
9720 on init
9721 declare %foo[3] := ( 1m, 1, 1k )
9722 declare %bar[3] := ( 1k, 1, 1m )
9723 exit( array_equal(%foo, %bar) )
9724 end on
9725 )NKSP_CODE",
9726 .expectBoolExitResult = false
9727 });
9728
9729 runScript({
9730 .code = R"NKSP_CODE(
9731 on init
9732 declare %foo[3] := ( 1, 1k, 1 )
9733 declare %bar[3] := ( 1, 1, 1 )
9734 exit( array_equal(%foo, %bar) )
9735 end on
9736 )NKSP_CODE",
9737 .expectBoolExitResult = false
9738 });
9739
9740 runScript({
9741 .code = R"NKSP_CODE(
9742 on init
9743 declare %foo[3] := ( 1, 1k, 1 )
9744 declare %bar[3] := ( 1, 1000, 1 )
9745 exit( array_equal(%foo, %bar) )
9746 end on
9747 )NKSP_CODE",
9748 .expectBoolExitResult = true
9749 });
9750
9751 runScript({
9752 .code = R"NKSP_CODE(
9753 on init
9754 declare %foo[3] := ( 1, 2, 3000 )
9755 declare %bar[3] := ( 1, 2, 3k )
9756 exit( array_equal(%foo, %bar) )
9757 end on
9758 )NKSP_CODE",
9759 .expectBoolExitResult = true
9760 });
9761
9762 runScript({
9763 .code = R"NKSP_CODE(
9764 on init
9765 declare %foo[3] := ( 1, 2, 3m )
9766 declare %bar[3] := ( 1, 2, 3k )
9767 exit( array_equal(%foo, %bar) )
9768 end on
9769 )NKSP_CODE",
9770 .expectBoolExitResult = false
9771 });
9772
9773 runScript({
9774 .code = R"NKSP_CODE(
9775 on init
9776 declare ?foo[4] := ( 1.0, 1.0m, 1.1m, 3.4k )
9777 declare ?bar[4] := ( 1.0, 1.0m, 1.1m, 3.4k )
9778 exit( array_equal(?foo, ?bar) )
9779 end on
9780 )NKSP_CODE",
9781 .expectBoolExitResult = true
9782 });
9783
9784 runScript({
9785 .code = R"NKSP_CODE(
9786 on init
9787 declare ?foo[4] := ( 1.0, 1.0m, 1.1m, 3.4k )
9788 declare ?bar[4] := ( 1.0, 1.0 , 1.1m, 3.4k )
9789 exit( array_equal(?foo, ?bar) )
9790 end on
9791 )NKSP_CODE",
9792 .expectBoolExitResult = false
9793 });
9794
9795 runScript({
9796 .code = R"NKSP_CODE(
9797 on init
9798 declare ?foo[4] := ( 1.0, 1.0m, 1.1m, 3.4k )
9799 declare ?bar[4] := ( 1.0, 1.0m, 1.1k, 3.4k )
9800 exit( array_equal(?foo, ?bar) )
9801 end on
9802 )NKSP_CODE",
9803 .expectBoolExitResult = false
9804 });
9805
9806 runScript({
9807 .code = R"NKSP_CODE(
9808 on init
9809 declare ?foo[4] := ( 1.0, 1.0m, 1.1m, 3.4k )
9810 declare ?bar[4] := ( 1.0, 1.0m, 1.1m, 3.4u )
9811 exit( array_equal(?foo, ?bar) )
9812 end on
9813 )NKSP_CODE",
9814 .expectBoolExitResult = false
9815 });
9816
9817 runScript({
9818 .code = R"NKSP_CODE(
9819 on init
9820 declare ?foo[3] := ( 1.0, 1.0k, 1.1m )
9821 declare ?bar[3] := ( 1.0, 1000.0, 1.1m )
9822 exit( array_equal(?foo, ?bar) )
9823 end on
9824 )NKSP_CODE",
9825 .expectBoolExitResult = true
9826 });
9827
9828 runScript({
9829 .code = R"NKSP_CODE(
9830 on init
9831 declare ?foo[3] := ( 1.0, 1.0k, 1.1u )
9832 declare ?bar[3] := ( 1.0, 1000.0, 0.0011m )
9833 exit( array_equal(?foo, ?bar) )
9834 end on
9835 )NKSP_CODE",
9836 .expectBoolExitResult = true
9837 });
9838
9839 runScript({
9840 .code = R"NKSP_CODE(
9841 on init
9842 declare ?foo[3] := ( 1.0, 1.0k, 1.1u )
9843 declare ?bar[3] := ( 1.0, 1000.0, 0.0016m )
9844 exit( array_equal(?foo, ?bar) )
9845 end on
9846 )NKSP_CODE",
9847 .expectBoolExitResult = false
9848 });
9849
9850 // 'final' ('!') operator tests ...
9851 // (currently prohibited for arrays)
9852
9853 runScript({
9854 .code = R"NKSP_CODE(
9855 on init
9856 declare %foo[3] := ( !1, !1, !1 )
9857 declare %bar[3] := ( !1, !1, !1 )
9858 exit( array_equal(%foo, %bar) )
9859 end on
9860 )NKSP_CODE",
9861 .expectParseError = true // see comment above
9862 });
9863
9864 runScript({
9865 .code = R"NKSP_CODE(
9866 on init
9867 declare ?foo[3] := ( !1.0, !1.0, !1.0 )
9868 declare ?bar[3] := ( !1.0, !1.0, !1.0 )
9869 exit( array_equal(?foo, ?bar) )
9870 end on
9871 )NKSP_CODE",
9872 .expectParseError = true // see comment above
9873 });
9874
9875 #if !SILENT_TEST
9876 std::cout << std::endl;
9877 #endif
9878 }
9879
9880 static void testBuiltInSortFunction() {
9881 #if !SILENT_TEST
9882 std::cout << "UNIT TEST: built-in sort() function\n";
9883 #endif
9884
9885 // integer array tests ...
9886
9887 runScript({
9888 .code = R"NKSP_CODE(
9889 on init
9890 declare %input[3] := ( 19, 3, 6 )
9891 declare %expected[3] := ( 3, 6, 19 )
9892 sort(%input, 0)
9893 exit( array_equal(%input, %expected) )
9894 end on
9895 )NKSP_CODE",
9896 .expectBoolExitResult = true
9897 });
9898
9899 runScript({
9900 .code = R"NKSP_CODE(
9901 on init
9902 declare %input[3] := ( 19, 3, 6 )
9903 declare %expected[3] := ( 19, 6, 3 )
9904 sort(%input, 1)
9905 exit( array_equal(%input, %expected) )
9906 end on
9907 )NKSP_CODE",
9908 .expectBoolExitResult = true
9909 });
9910
9911 runScript({
9912 .code = R"NKSP_CODE(
9913 on init
9914 declare %input[6] := ( 1, 80, 120, 40, 3000, 20 )
9915 declare %expected[6] := ( 1, 20, 40, 80, 120, 3000 )
9916 sort(%input, 0)
9917 exit( array_equal(%input, %expected) )
9918 end on
9919 )NKSP_CODE",
9920 .expectBoolExitResult = true
9921 });
9922
9923 // real number array tests ...
9924
9925 runScript({
9926 .code = R"NKSP_CODE(
9927 on init
9928 declare ?input[4] := ( 1.4, 1.0, 13.4, 2.7 )
9929 declare ?expected[4] := ( 1.0, 1.4, 2.7, 13.4 )
9930 sort(?input, 0)
9931 exit( array_equal(?input, ?expected) )
9932 end on
9933 )NKSP_CODE",
9934 .expectBoolExitResult = true
9935 });
9936
9937 runScript({
9938 .code = R"NKSP_CODE(
9939 on init
9940 declare ?input[4] := ( 1.4, 1.0, 13.4, 2.7 )
9941 declare ?expected[4] := ( 13.4, 2.7, 1.4, 1.0 )
9942 sort(?input, 1)
9943 exit( array_equal(?input, ?expected) )
9944 end on
9945 )NKSP_CODE",
9946 .expectBoolExitResult = true
9947 });
9948
9949 // std unit tests ...
9950 // (only metric prefixes are allowed for arrays ATM)
9951
9952 runScript({
9953 .code = R"NKSP_CODE(
9954 on init
9955 declare %input[3] := ( 1k, 6, 900 )
9956 declare %expected[3] := ( 6, 900, 1k )
9957 sort(%input, 0)
9958 exit( array_equal(%input, %expected) )
9959 end on
9960 )NKSP_CODE",
9961 .expectBoolExitResult = true
9962 });
9963
9964 runScript({
9965 .code = R"NKSP_CODE(
9966 on init
9967 declare %input[3] := ( 900, 1k, 6 )
9968 declare %expected[3] := ( 1k, 900, 6 )
9969 sort(%input, 1)
9970 exit( array_equal(%input, %expected) )
9971 end on
9972 )NKSP_CODE",
9973 .expectBoolExitResult = true
9974 });
9975
9976 runScript({
9977 .code = R"NKSP_CODE(
9978 on init
9979 declare %input[6] := ( 1k, 8m, 4k, 12000u, 3000u, 1000u )
9980 declare %expected[6] := ( 1000u, 3000u, 8m, 12000u, 1k, 4k )
9981 sort(%input, 0)
9982 exit( array_equal(%input, %expected) )
9983 end on
9984 )NKSP_CODE",
9985 .expectBoolExitResult = true
9986 });
9987
9988 runScript({
9989 .code = R"NKSP_CODE(
9990 on init
9991 declare ?input[3] := ( 1.0k, 6.0, 900.0 )
9992 declare ?expected[3] := ( 6.0, 900.0, 1.0k )
9993 sort(?input, 0)
9994 exit( array_equal(?input, ?expected) )
9995 end on
9996 )NKSP_CODE",
9997 .expectBoolExitResult = true
9998 });
9999
10000 runScript({
10001 .code = R"NKSP_CODE(
10002 on init
10003 declare ?input[3] := ( 900.0, 1.0k, 6.0 )
10004 declare ?expected[3] := ( 1.0k, 900.0, 6.0 )
10005 sort(?input, 1)
10006 exit( array_equal(?input, ?expected) )
10007 end on
10008 )NKSP_CODE",
10009 .expectBoolExitResult = true
10010 });
10011
10012 runScript({
10013 .code = R"NKSP_CODE(
10014 on init
10015 declare ?input[3] := ( 1.0k, 0.9k, 1.1k )
10016 declare ?expected[3] := ( 0.9k, 1.0k, 1.1k )
10017 sort(?input, 0)
10018 exit( array_equal(?input, ?expected) )
10019 end on
10020 )NKSP_CODE",
10021 .expectBoolExitResult = true
10022 });
10023
10024 runScript({
10025 .code = R"NKSP_CODE(
10026 on init
10027 declare ?input[3] := ( 2.0m, 1000.1u, 1.0 )
10028 declare ?expected[3] := ( 1000.1u, 2.0m, 1.0 )
10029 sort(?input, 0)
10030 exit( array_equal(?input, ?expected) )
10031 end on
10032 )NKSP_CODE",
10033 .expectBoolExitResult = true
10034 });
10035
10036 runScript({
10037 .code = R"NKSP_CODE(
10038 on init
10039 declare ?input[4] := ( 2.0m, 1000.1u, 1.0, 1400.0u )
10040 declare ?expected[4] := ( 1000.1u, 1400.0u, 2.0m, 1.0 )
10041 sort(?input, 0)
10042 exit( array_equal(?input, ?expected) )
10043 end on
10044 )NKSP_CODE",
10045 .expectBoolExitResult = true
10046 });
10047
10048 runScript({
10049 .code = R"NKSP_CODE(
10050 on init
10051 declare ?input[4] := ( 2.0m, 1000.1u, 1.0, 1400.0u )
10052 declare ?expected[4] := ( 1.0, 2.0m, 1400.0u, 1000.1u )
10053 sort(?input, 1)
10054 exit( array_equal(?input, ?expected) )
10055 end on
10056 )NKSP_CODE",
10057 .expectBoolExitResult = true
10058 });
10059
10060 runScript({
10061 .code = R"NKSP_CODE(
10062 on init
10063 declare ?input[6] := ( 0.9k, 8.0m, 1.1k, 12000.0u, 3000.0u, 1000.0u )
10064 declare ?expected[6] := ( 1000.0u, 3000.0u, 8.0m, 12000.0u, 0.9k, 1.1k )
10065 sort(?input, 0)
10066 exit( array_equal(?input, ?expected) )
10067 end on
10068 )NKSP_CODE",
10069 .expectBoolExitResult = true
10070 });
10071
10072 runScript({
10073 .code = R"NKSP_CODE(
10074 on init
10075 declare ?input[6] := ( 0.9k, 8.0m, 1.1k, 12000.0u, 3000.0u, 1000.0u )
10076 declare ?expected[6] := ( 1.1k, 0.9k, 12000.0u, 8.0m, 3000.0u, 1000.0u )
10077 sort(?input, 1)
10078 exit( array_equal(?input, ?expected) )
10079 end on
10080 )NKSP_CODE",
10081 .expectBoolExitResult = true
10082 });
10083
10084 #if !SILENT_TEST
10085 std::cout << std::endl;
10086 #endif
10087 }
10088
10089 static void testBuiltInRoundFunction() {
10090 #if !SILENT_TEST
10091 std::cout << "UNIT TEST: built-in round() function\n";
10092 #endif
10093
10094 // integer tests ...
10095 // (ATM not allowed for this function)
10096
10097 runScript({
10098 .code = R"NKSP_CODE(
10099 on init
10100 declare $foo := 1
10101 exit( round($foo) )
10102 end on
10103 )NKSP_CODE",
10104 .expectParseError = true // integer not allowed for this function ATM
10105 });
10106
10107 // real number tests ...
10108
10109 runScript({
10110 .code = R"NKSP_CODE(
10111 on init
10112 exit( round(99.4) )
10113 end on
10114 )NKSP_CODE",
10115 .expectRealExitResult = 99.0
10116 });
10117
10118 runScript({
10119 .code = R"NKSP_CODE(
10120 on init
10121 exit( round(99.5) )
10122 end on
10123 )NKSP_CODE",
10124 .expectRealExitResult = 100.0
10125 });
10126
10127 // std unit tests ...
10128
10129 runScript({
10130 .code = R"NKSP_CODE(
10131 on init
10132 exit( round(2.4ms) )
10133 end on
10134 )NKSP_CODE",
10135 .expectRealExitResult = 2.0,
10136 .expectExitResultUnitPrefix = { VM_MILLI },
10137 .expectExitResultUnit = VM_SECOND
10138 });
10139
10140 runScript({
10141 .code = R"NKSP_CODE(
10142 on init
10143 exit( round(2.6kHz) )
10144 end on
10145 )NKSP_CODE",
10146 .expectRealExitResult = 3.0,
10147 .expectExitResultUnitPrefix = { VM_KILO },
10148 .expectExitResultUnit = VM_HERTZ
10149 });
10150
10151 // 'final' ('!') operator tests ...
10152
10153 runScript({
10154 .code = R"NKSP_CODE(
10155 on init
10156 exit( round(123.8) )
10157 end on
10158 )NKSP_CODE",
10159 .expectRealExitResult = 124.0,
10160 .expectExitResultFinal = false
10161 });
10162
10163 runScript({
10164 .code = R"NKSP_CODE(
10165 on init
10166 exit( round(!123.8) )
10167 end on
10168 )NKSP_CODE",
10169 .expectRealExitResult = 124.0,
10170 .expectExitResultFinal = true
10171 });
10172
10173 #if !SILENT_TEST
10174 std::cout << std::endl;
10175 #endif
10176 }
10177
10178 static void testBuiltInCeilFunction() {
10179 #if !SILENT_TEST
10180 std::cout << "UNIT TEST: built-in ceil() function\n";
10181 #endif
10182
10183 // integer tests ...
10184 // (ATM not allowed for this function)
10185
10186 runScript({
10187 .code = R"NKSP_CODE(
10188 on init
10189 declare $foo := 1
10190 exit( ceil($foo) )
10191 end on
10192 )NKSP_CODE",
10193 .expectParseError = true // integer not allowed for this function ATM
10194 });
10195
10196 // real number tests ...
10197
10198 runScript({
10199 .code = R"NKSP_CODE(
10200 on init
10201 exit( ceil(99.0) )
10202 end on
10203 )NKSP_CODE",
10204 .expectRealExitResult = 99.0
10205 });
10206
10207 runScript({
10208 .code = R"NKSP_CODE(
10209 on init
10210 exit( ceil(99.1) )
10211 end on
10212 )NKSP_CODE",
10213 .expectRealExitResult = 100.0
10214 });
10215
10216 runScript({
10217 .code = R"NKSP_CODE(
10218 on init
10219 exit( ceil(99.9) )
10220 end on
10221 )NKSP_CODE",
10222 .expectRealExitResult = 100.0
10223 });
10224
10225 // std unit tests ...
10226
10227 runScript({
10228 .code = R"NKSP_CODE(
10229 on init
10230 exit( ceil(2.4ms) )
10231 end on
10232 )NKSP_CODE",
10233 .expectRealExitResult = 3.0,
10234 .expectExitResultUnitPrefix = { VM_MILLI },
10235 .expectExitResultUnit = VM_SECOND
10236 });
10237
10238 runScript({
10239 .code = R"NKSP_CODE(
10240 on init
10241 exit( ceil(2.6kHz) )
10242 end on
10243 )NKSP_CODE",
10244 .expectRealExitResult = 3.0,
10245 .expectExitResultUnitPrefix = { VM_KILO },
10246 .expectExitResultUnit = VM_HERTZ
10247 });
10248
10249 runScript({
10250 .code = R"NKSP_CODE(
10251 on init
10252 exit( ceil(9.4ms / 2.0) )
10253 end on
10254 )NKSP_CODE",
10255 .expectRealExitResult = 5.0,
10256 .expectExitResultUnitPrefix = { VM_MILLI },
10257 .expectExitResultUnit = VM_SECOND
10258 });
10259
10260 runScript({
10261 .code = R"NKSP_CODE(
10262 on init
10263 exit( ceil( ceil(8.4us) / 2.0) )
10264 end on
10265 )NKSP_CODE",
10266 .expectRealExitResult = 5.0,
10267 .expectExitResultUnitPrefix = { VM_MICRO },
10268 .expectExitResultUnit = VM_SECOND
10269 });
10270
10271 // 'final' ('!') operator tests ...
10272
10273 runScript({
10274 .code = R"NKSP_CODE(
10275 on init
10276 exit( ceil(123.1) )
10277 end on
10278 )NKSP_CODE",
10279 .expectRealExitResult = 124.0,
10280 .expectExitResultFinal = false
10281 });
10282
10283 runScript({
10284 .code = R"NKSP_CODE(
10285 on init
10286 exit( ceil(!123.8) )
10287 end on
10288 )NKSP_CODE",
10289 .expectRealExitResult = 124.0,
10290 .expectExitResultFinal = true
10291 });
10292
10293 #if !SILENT_TEST
10294 std::cout << std::endl;
10295 #endif
10296 }
10297
10298 static void testBuiltInFloorFunction() {
10299 #if !SILENT_TEST
10300 std::cout << "UNIT TEST: built-in floor() function\n";
10301 #endif
10302
10303 // integer tests ...
10304 // (ATM not allowed for this function)
10305
10306 runScript({
10307 .code = R"NKSP_CODE(
10308 on init
10309 declare $foo := 1
10310 exit( floor($foo) )
10311 end on
10312 )NKSP_CODE",
10313 .expectParseError = true // integer not allowed for this function ATM
10314 });
10315
10316 // real number tests ...
10317
10318 runScript({
10319 .code = R"NKSP_CODE(
10320 on init
10321 exit( floor(99.0) )
10322 end on
10323 )NKSP_CODE",
10324 .expectRealExitResult = 99.0
10325 });
10326
10327 runScript({
10328 .code = R"NKSP_CODE(
10329 on init
10330 exit( floor(99.1) )
10331 end on
10332 )NKSP_CODE",
10333 .expectRealExitResult = 99.0
10334 });
10335
10336 runScript({
10337 .code = R"NKSP_CODE(
10338 on init
10339 exit( floor(99.9) )
10340 end on
10341 )NKSP_CODE",
10342 .expectRealExitResult = 99.0
10343 });
10344
10345 // std unit tests ...
10346
10347 runScript({
10348 .code = R"NKSP_CODE(
10349 on init
10350 exit( floor(2.4ms) )
10351 end on
10352 )NKSP_CODE",
10353 .expectRealExitResult = 2.0,
10354 .expectExitResultUnitPrefix = { VM_MILLI },
10355 .expectExitResultUnit = VM_SECOND
10356 });
10357
10358 runScript({
10359 .code = R"NKSP_CODE(
10360 on init
10361 exit( floor(2.6kHz) )
10362 end on
10363 )NKSP_CODE",
10364 .expectRealExitResult = 2.0,
10365 .expectExitResultUnitPrefix = { VM_KILO },
10366 .expectExitResultUnit = VM_HERTZ
10367 });
10368
10369 runScript({
10370 .code = R"NKSP_CODE(
10371 on init
10372 exit( floor(4.4ms / 2.0) )
10373 end on
10374 )NKSP_CODE",
10375 .expectRealExitResult = 2.0,
10376 .expectExitResultUnitPrefix = { VM_MILLI },
10377 .expectExitResultUnit = VM_SECOND
10378 });
10379
10380 runScript({
10381 .code = R"NKSP_CODE(
10382 on init
10383 exit( floor( floor(8.4us) / 4.0) )
10384 end on
10385 )NKSP_CODE",
10386 .expectRealExitResult = 2.0,
10387 .expectExitResultUnitPrefix = { VM_MICRO },
10388 .expectExitResultUnit = VM_SECOND
10389 });
10390
10391 // 'final' ('!') operator tests ...
10392
10393 runScript({
10394 .code = R"NKSP_CODE(
10395 on init
10396 exit( floor(123.1) )
10397 end on
10398 )NKSP_CODE",
10399 .expectRealExitResult = 123.0,
10400 .expectExitResultFinal = false
10401 });
10402
10403 runScript({
10404 .code = R"NKSP_CODE(
10405 on init
10406 exit( floor(!123.8) )
10407 end on
10408 )NKSP_CODE",
10409 .expectRealExitResult = 123.0,
10410 .expectExitResultFinal = true
10411 });
10412
10413 #if !SILENT_TEST
10414 std::cout << std::endl;
10415 #endif
10416 }
10417
10418 static void testBuiltInSqrtFunction() {
10419 #if !SILENT_TEST
10420 std::cout << "UNIT TEST: built-in sqrt() function\n";
10421 #endif
10422
10423 // integer tests ...
10424 // (ATM not allowed for this function)
10425
10426 runScript({
10427 .code = R"NKSP_CODE(
10428 on init
10429 declare $foo := 1
10430 exit( sqrt($foo) )
10431 end on
10432 )NKSP_CODE",
10433 .expectParseError = true // integer not allowed for this function ATM
10434 });
10435
10436 // real number tests ...
10437
10438 runScript({
10439 .code = R"NKSP_CODE(
10440 on init
10441 exit( sqrt(36.0) )
10442 end on
10443 )NKSP_CODE",
10444 .expectRealExitResult = 6.0
10445 });
10446
10447 // std unit tests ...
10448
10449 runScript({
10450 .code = R"NKSP_CODE(
10451 on init
10452 exit( sqrt(100.0ms) )
10453 end on
10454 )NKSP_CODE",
10455 .expectRealExitResult = 10.0,
10456 .expectExitResultUnitPrefix = { VM_MILLI },
10457 .expectExitResultUnit = VM_SECOND
10458 });
10459
10460 runScript({
10461 .code = R"NKSP_CODE(
10462 on init
10463 exit( sqrt(5.76kHz) )
10464 end on
10465 )NKSP_CODE",
10466 .expectRealExitResult = 2.4,
10467 .expectExitResultUnitPrefix = { VM_KILO },
10468 .expectExitResultUnit = VM_HERTZ
10469 });
10470
10471 // 'final' ('!') operator tests ...
10472
10473 runScript({
10474 .code = R"NKSP_CODE(
10475 on init
10476 exit( sqrt(25.0) )
10477 end on
10478 )NKSP_CODE",
10479 .expectRealExitResult = 5.0,
10480 .expectExitResultFinal = false
10481 });
10482
10483 runScript({
10484 .code = R"NKSP_CODE(
10485 on init
10486 exit( sqrt(!25.0) )
10487 end on
10488 )NKSP_CODE",
10489 .expectRealExitResult = 5.0,
10490 .expectExitResultFinal = true
10491 });
10492
10493 #if !SILENT_TEST
10494 std::cout << std::endl;
10495 #endif
10496 }
10497
10498 static void testBuiltInLogFunction() {
10499 #if !SILENT_TEST
10500 std::cout << "UNIT TEST: built-in log() function\n";
10501 #endif
10502
10503 // integer tests ...
10504 // (ATM not allowed for this function)
10505
10506 runScript({
10507 .code = R"NKSP_CODE(
10508 on init
10509 declare $foo := 1
10510 exit( log($foo) )
10511 end on
10512 )NKSP_CODE",
10513 .expectParseError = true // integer not allowed for this function ATM
10514 });
10515
10516 // real number tests ...
10517
10518 runScript({
10519 .code = R"NKSP_CODE(
10520 on init
10521 exit( log(1.0) )
10522 end on
10523 )NKSP_CODE",
10524 .expectRealExitResult = 0.0
10525 });
10526
10527 runScript({
10528 .code = R"NKSP_CODE(
10529 on init
10530 exit( log(~NI_MATH_E) )
10531 end on
10532 )NKSP_CODE",
10533 .expectRealExitResult = 1.0
10534 });
10535
10536 // std unit tests ...
10537
10538 runScript({
10539 .code = R"NKSP_CODE(
10540 on init
10541 exit( log(~NI_MATH_E * 1.0ms) )
10542 end on
10543 )NKSP_CODE",
10544 .expectRealExitResult = 1.0,
10545 .expectExitResultUnitPrefix = { VM_MILLI },
10546 .expectExitResultUnit = VM_SECOND
10547 });
10548
10549 runScript({
10550 .code = R"NKSP_CODE(
10551 on init
10552 exit( log(~NI_MATH_E * 1.0kHz) )
10553 end on
10554 )NKSP_CODE",
10555 .expectRealExitResult = 1.0,
10556 .expectExitResultUnitPrefix = { VM_KILO },
10557 .expectExitResultUnit = VM_HERTZ
10558 });
10559
10560 // 'final' ('!') operator tests ...
10561
10562 runScript({
10563 .code = R"NKSP_CODE(
10564 on init
10565 exit( log(~NI_MATH_E * 1.0) )
10566 end on
10567 )NKSP_CODE",
10568 .expectRealExitResult = 1.0,
10569 .expectExitResultFinal = false
10570 });
10571
10572 runScript({
10573 .code = R"NKSP_CODE(
10574 on init
10575 exit( log(!(~NI_MATH_E * 1.0)) )
10576 end on
10577 )NKSP_CODE",
10578 .expectRealExitResult = 1.0,
10579 .expectExitResultFinal = true
10580 });
10581
10582 #if !SILENT_TEST
10583 std::cout << std::endl;
10584 #endif
10585 }
10586
10587 static void testBuiltInLog2Function() {
10588 #if !SILENT_TEST
10589 std::cout << "UNIT TEST: built-in log2() function\n";
10590 #endif
10591
10592 // integer tests ...
10593 // (ATM not allowed for this function)
10594
10595 runScript({
10596 .code = R"NKSP_CODE(
10597 on init
10598 declare $foo := 1
10599 exit( log2($foo) )
10600 end on
10601 )NKSP_CODE",
10602 .expectParseError = true // integer not allowed for this function ATM
10603 });
10604
10605 // real number tests ...
10606
10607 runScript({
10608 .code = R"NKSP_CODE(
10609 on init
10610 exit( log2(1.0) )
10611 end on
10612 )NKSP_CODE",
10613 .expectRealExitResult = 0.0
10614 });
10615
10616 runScript({
10617 .code = R"NKSP_CODE(
10618 on init
10619 exit( log2(32.0) )
10620 end on
10621 )NKSP_CODE",
10622 .expectRealExitResult = 5.0
10623 });
10624
10625 // std unit tests ...
10626
10627 runScript({
10628 .code = R"NKSP_CODE(
10629 on init
10630 exit( log2(32.0ms) )
10631 end on
10632 )NKSP_CODE",
10633 .expectRealExitResult = 5.0,
10634 .expectExitResultUnitPrefix = { VM_MILLI },
10635 .expectExitResultUnit = VM_SECOND
10636 });
10637
10638 runScript({
10639 .code = R"NKSP_CODE(
10640 on init
10641 exit( log2(32.0kHz) )
10642 end on
10643 )NKSP_CODE",
10644 .expectRealExitResult = 5.0,
10645 .expectExitResultUnitPrefix = { VM_KILO },
10646 .expectExitResultUnit = VM_HERTZ
10647 });
10648
10649 // 'final' ('!') operator tests ...
10650
10651 runScript({
10652 .code = R"NKSP_CODE(
10653 on init
10654 exit( log2(32.0) )
10655 end on
10656 )NKSP_CODE",
10657 .expectRealExitResult = 5.0,
10658 .expectExitResultFinal = false
10659 });
10660
10661 runScript({
10662 .code = R"NKSP_CODE(
10663 on init
10664 exit( log2(!32.0) )
10665 end on
10666 )NKSP_CODE",
10667 .expectRealExitResult = 5.0,
10668 .expectExitResultFinal = true
10669 });
10670
10671 #if !SILENT_TEST
10672 std::cout << std::endl;
10673 #endif
10674 }
10675
10676 static void testBuiltInLog10Function() {
10677 #if !SILENT_TEST
10678 std::cout << "UNIT TEST: built-in log10() function\n";
10679 #endif
10680
10681 // integer tests ...
10682 // (ATM not allowed for this function)
10683
10684 runScript({
10685 .code = R"NKSP_CODE(
10686 on init
10687 declare $foo := 1
10688 exit( log10($foo) )
10689 end on
10690 )NKSP_CODE",
10691 .expectParseError = true // integer not allowed for this function ATM
10692 });
10693
10694 // real number tests ...
10695
10696 runScript({
10697 .code = R"NKSP_CODE(
10698 on init
10699 exit( log10(1000.0) )
10700 end on
10701 )NKSP_CODE",
10702 .expectRealExitResult = 3.0
10703 });
10704
10705 runScript({
10706 .code = R"NKSP_CODE(
10707 on init
10708 exit( log10(1000.0) )
10709 end on
10710 )NKSP_CODE",
10711 .expectRealExitResult = 3.0
10712 });
10713
10714 // std unit tests ...
10715
10716 runScript({
10717 .code = R"NKSP_CODE(
10718 on init
10719 exit( log10(1000.0ms) )
10720 end on
10721 )NKSP_CODE",
10722 .expectRealExitResult = 3.0,
10723 .expectExitResultUnitPrefix = { VM_MILLI },
10724 .expectExitResultUnit = VM_SECOND
10725 });
10726
10727 runScript({
10728 .code = R"NKSP_CODE(
10729 on init
10730 exit( log10(1000.0kHz) )
10731 end on
10732 )NKSP_CODE",
10733 .expectRealExitResult = 3.0,
10734 .expectExitResultUnitPrefix = { VM_KILO },
10735 .expectExitResultUnit = VM_HERTZ
10736 });
10737
10738 // 'final' ('!') operator tests ...
10739
10740 runScript({
10741 .code = R"NKSP_CODE(
10742 on init
10743 exit( log10(1000.0) )
10744 end on
10745 )NKSP_CODE",
10746 .expectRealExitResult = 3.0,
10747 .expectExitResultFinal = false
10748 });
10749
10750 runScript({
10751 .code = R"NKSP_CODE(
10752 on init
10753 exit( log10(!1000.0) )
10754 end on
10755 )NKSP_CODE",
10756 .expectRealExitResult = 3.0,
10757 .expectExitResultFinal = true
10758 });
10759
10760 #if !SILENT_TEST
10761 std::cout << std::endl;
10762 #endif
10763 }
10764
10765 static void testBuiltInExpFunction() {
10766 #if !SILENT_TEST
10767 std::cout << "UNIT TEST: built-in exp() function\n";
10768 #endif
10769
10770 // integer tests ...
10771 // (ATM not allowed for this function)
10772
10773 runScript({
10774 .code = R"NKSP_CODE(
10775 on init
10776 declare $foo := 1
10777 exit( exp($foo) )
10778 end on
10779 )NKSP_CODE",
10780 .expectParseError = true // integer not allowed for this function ATM
10781 });
10782
10783 // real number tests ...
10784
10785 runScript({
10786 .code = R"NKSP_CODE(
10787 on init
10788 exit( exp(0.0) )
10789 end on
10790 )NKSP_CODE",
10791 .expectRealExitResult = 1.0
10792 });
10793
10794 runScript({
10795 .code = R"NKSP_CODE(
10796 on init
10797 exit( exp(1.0) )
10798 end on
10799 )NKSP_CODE",
10800 .expectRealExitResult = M_E
10801 });
10802
10803 // std unit tests ...
10804
10805 runScript({
10806 .code = R"NKSP_CODE(
10807 on init
10808 exit( exp(0.0ms) )
10809 end on
10810 )NKSP_CODE",
10811 .expectRealExitResult = 1.0,
10812 .expectExitResultUnitPrefix = { VM_MILLI },
10813 .expectExitResultUnit = VM_SECOND
10814 });
10815
10816 runScript({
10817 .code = R"NKSP_CODE(
10818 on init
10819 exit( exp(0.0kHz) )
10820 end on
10821 )NKSP_CODE",
10822 .expectRealExitResult = 1.0,
10823 .expectExitResultUnitPrefix = { VM_KILO },
10824 .expectExitResultUnit = VM_HERTZ
10825 });
10826
10827 // 'final' ('!') operator tests ...
10828
10829 runScript({
10830 .code = R"NKSP_CODE(
10831 on init
10832 exit( exp(0.0) )
10833 end on
10834 )NKSP_CODE",
10835 .expectRealExitResult = 1.0,
10836 .expectExitResultFinal = false
10837 });
10838
10839 runScript({
10840 .code = R"NKSP_CODE(
10841 on init
10842 exit( exp(!0.0) )
10843 end on
10844 )NKSP_CODE",
10845 .expectRealExitResult = 1.0,
10846 .expectExitResultFinal = true
10847 });
10848
10849 #if !SILENT_TEST
10850 std::cout << std::endl;
10851 #endif
10852 }
10853
10854 static void testBuiltInPowFunction() {
10855 #if !SILENT_TEST
10856 std::cout << "UNIT TEST: built-in pow() function\n";
10857 #endif
10858
10859 // integer tests ...
10860 // (ATM not allowed for this function)
10861
10862 runScript({
10863 .code = R"NKSP_CODE(
10864 on init
10865 declare $foo := 1
10866 exit( pow($foo,$foo) )
10867 end on
10868 )NKSP_CODE",
10869 .expectParseError = true // integer not allowed for this function ATM
10870 });
10871
10872 // real number tests ...
10873
10874 runScript({
10875 .code = R"NKSP_CODE(
10876 on init
10877 exit( pow(1.0) )
10878 end on
10879 )NKSP_CODE",
10880 .expectParseError = true // because pow() requires exactly 2 arguments
10881 });
10882
10883 runScript({
10884 .code = R"NKSP_CODE(
10885 on init
10886 exit( pow(3.0,4.0) )
10887 end on
10888 )NKSP_CODE",
10889 .expectRealExitResult = 81.0
10890 });
10891
10892 // std unit tests ...
10893
10894 runScript({
10895 .code = R"NKSP_CODE(
10896 on init
10897 exit( pow(3.0ms,4.0ms) )
10898 end on
10899 )NKSP_CODE",
10900 .expectParseError = true // because units are prohibited for 2nd argument
10901 });
10902
10903 runScript({
10904 .code = R"NKSP_CODE(
10905 on init
10906 exit( pow(3.0,4.0ms) )
10907 end on
10908 )NKSP_CODE",
10909 .expectParseError = true // because units are prohibited for 2nd argument
10910 });
10911
10912 runScript({
10913 .code = R"NKSP_CODE(
10914 on init
10915 exit( pow(3.0ms,4.0) )
10916 end on
10917 )NKSP_CODE",
10918 .expectRealExitResult = 81.0,
10919 .expectExitResultUnitPrefix = { VM_MILLI },
10920 .expectExitResultUnit = VM_SECOND
10921 });
10922
10923 runScript({
10924 .code = R"NKSP_CODE(
10925 on init
10926 exit( pow(3.0kHz,4.0) )
10927 end on
10928 )NKSP_CODE",
10929 .expectRealExitResult = 81.0,
10930 .expectExitResultUnitPrefix = { VM_KILO },
10931 .expectExitResultUnit = VM_HERTZ
10932 });
10933
10934 // 'final' ('!') operator tests ...
10935
10936 runScript({
10937 .code = R"NKSP_CODE(
10938 on init
10939 exit( pow(3.0,4.0) )
10940 end on
10941 )NKSP_CODE",
10942 .expectRealExitResult = 81.0,
10943 .expectExitResultFinal = false
10944 });
10945
10946 runScript({
10947 .code = R"NKSP_CODE(
10948 on init
10949 exit( pow(!3.0,4.0) )
10950 end on
10951 )NKSP_CODE",
10952 .expectRealExitResult = 81.0,
10953 .expectExitResultFinal = true
10954 });
10955
10956 runScript({
10957 .code = R"NKSP_CODE(
10958 on init
10959 exit( pow(3.0,!4.0) )
10960 end on
10961 )NKSP_CODE",
10962 .expectParseError = true // because 'final' is meaningless for 2nd argument
10963 });
10964
10965 #if !SILENT_TEST
10966 std::cout << std::endl;
10967 #endif
10968 }
10969
10970 static void testBuiltInSinFunction() {
10971 #if !SILENT_TEST
10972 std::cout << "UNIT TEST: built-in sin() function\n";
10973 #endif
10974
10975 // integer tests ...
10976 // (ATM not allowed for this function)
10977
10978 runScript({
10979 .code = R"NKSP_CODE(
10980 on init
10981 declare $foo := 1
10982 exit( sin($foo) )
10983 end on
10984 )NKSP_CODE",
10985 .expectParseError = true // integer not allowed for this function ATM
10986 });
10987
10988 // real number tests ...
10989
10990 runScript({
10991 .code = R"NKSP_CODE(
10992 on init
10993 exit( sin(0.0) )
10994 end on
10995 )NKSP_CODE",
10996 .expectRealExitResult = 0.0
10997 });
10998
10999 runScript({
11000 .code = R"NKSP_CODE(
11001 on init
11002 exit( sin(0.5 * ~NI_MATH_PI) )
11003 end on
11004 )NKSP_CODE",
11005 .expectRealExitResult = 1.0
11006 });
11007
11008 runScript({
11009 .code = R"NKSP_CODE(
11010 on init
11011 exit( sin(~NI_MATH_PI) )
11012 end on
11013 )NKSP_CODE",
11014 .expectRealExitResult = 0.0
11015 });
11016
11017 runScript({
11018 .code = R"NKSP_CODE(
11019 on init
11020 exit( sin(1.5 * ~NI_MATH_PI) )
11021 end on
11022 )NKSP_CODE",
11023 .expectRealExitResult = -1.0
11024 });
11025
11026 // std unit tests ...
11027
11028 runScript({
11029 .code = R"NKSP_CODE(
11030 on init
11031 exit( sin(0.0ms) )
11032 end on
11033 )NKSP_CODE",
11034 .expectRealExitResult = 0.0,
11035 .expectExitResultUnitPrefix = { VM_MILLI },
11036 .expectExitResultUnit = VM_SECOND
11037 });
11038
11039 runScript({
11040 .code = R"NKSP_CODE(
11041 on init
11042 exit( sin(0.0kHz) )
11043 end on
11044 )NKSP_CODE",
11045 .expectRealExitResult = 0.0,
11046 .expectExitResultUnitPrefix = { VM_KILO },
11047 .expectExitResultUnit = VM_HERTZ
11048 });
11049
11050 // 'final' ('!') operator tests ...
11051
11052 runScript({
11053 .code = R"NKSP_CODE(
11054 on init
11055 exit( sin(0.0) )
11056 end on
11057 )NKSP_CODE",
11058 .expectRealExitResult = 0.0,
11059 .expectExitResultFinal = false
11060 });
11061
11062 runScript({
11063 .code = R"NKSP_CODE(
11064 on init
11065 exit( sin(!0.0) )
11066 end on
11067 )NKSP_CODE",
11068 .expectRealExitResult = 0.0,
11069 .expectExitResultFinal = true
11070 });
11071
11072 #if !SILENT_TEST
11073 std::cout << std::endl;
11074 #endif
11075 }
11076
11077 static void testBuiltInCosFunction() {
11078 #if !SILENT_TEST
11079 std::cout << "UNIT TEST: built-in cos() function\n";
11080 #endif
11081
11082 // integer tests ...
11083 // (ATM not allowed for this function)
11084
11085 runScript({
11086 .code = R"NKSP_CODE(
11087 on init
11088 declare $foo := 1
11089 exit( cos($foo) )
11090 end on
11091 )NKSP_CODE",
11092 .expectParseError = true // integer not allowed for this function ATM
11093 });
11094
11095 // real number tests ...
11096
11097 runScript({
11098 .code = R"NKSP_CODE(
11099 on init
11100 exit( cos(0.0) )
11101 end on
11102 )NKSP_CODE",
11103 .expectRealExitResult = 1.0
11104 });
11105
11106 runScript({
11107 .code = R"NKSP_CODE(
11108 on init
11109 exit( cos(0.5 * ~NI_MATH_PI) )
11110 end on
11111 )NKSP_CODE",
11112 .expectRealExitResult = 0.0
11113 });
11114
11115 runScript({
11116 .code = R"NKSP_CODE(
11117 on init
11118 exit( cos(~NI_MATH_PI) )
11119 end on
11120 )NKSP_CODE",
11121 .expectRealExitResult = -1.0
11122 });
11123
11124 runScript({
11125 .code = R"NKSP_CODE(
11126 on init
11127 exit( cos(1.5 * ~NI_MATH_PI) )
11128 end on
11129 )NKSP_CODE",
11130 .expectRealExitResult = 0.0
11131 });
11132
11133 // std unit tests ...
11134
11135 runScript({
11136 .code = R"NKSP_CODE(
11137 on init
11138 exit( cos(0.0ms) )
11139 end on
11140 )NKSP_CODE",
11141 .expectRealExitResult = 1.0,
11142 .expectExitResultUnitPrefix = { VM_MILLI },
11143 .expectExitResultUnit = VM_SECOND
11144 });
11145
11146 runScript({
11147 .code = R"NKSP_CODE(
11148 on init
11149 exit( cos(0.0kHz) )
11150 end on
11151 )NKSP_CODE",
11152 .expectRealExitResult = 1.0,
11153 .expectExitResultUnitPrefix = { VM_KILO },
11154 .expectExitResultUnit = VM_HERTZ
11155 });
11156
11157 // 'final' ('!') operator tests ...
11158
11159 runScript({
11160 .code = R"NKSP_CODE(
11161 on init
11162 exit( cos(0.0) )
11163 end on
11164 )NKSP_CODE",
11165 .expectRealExitResult = 1.0,
11166 .expectExitResultFinal = false
11167 });
11168
11169 runScript({
11170 .code = R"NKSP_CODE(
11171 on init
11172 exit( cos(!0.0) )
11173 end on
11174 )NKSP_CODE",
11175 .expectRealExitResult = 1.0,
11176 .expectExitResultFinal = true
11177 });
11178
11179 #if !SILENT_TEST
11180 std::cout << std::endl;
11181 #endif
11182 }
11183
11184 static void testBuiltInTanFunction() {
11185 #if !SILENT_TEST
11186 std::cout << "UNIT TEST: built-in tan() function\n";
11187 #endif
11188
11189 // integer tests ...
11190 // (ATM not allowed for this function)
11191
11192 runScript({
11193 .code = R"NKSP_CODE(
11194 on init
11195 declare $foo := 1
11196 exit( tan($foo) )
11197 end on
11198 )NKSP_CODE",
11199 .expectParseError = true // integer not allowed for this function ATM
11200 });
11201
11202 // real number tests ...
11203
11204 runScript({
11205 .code = R"NKSP_CODE(
11206 on init
11207 exit( tan(0.0) )
11208 end on
11209 )NKSP_CODE",
11210 .expectRealExitResult = 0.0
11211 });
11212
11213 runScript({
11214 .code = R"NKSP_CODE(
11215 on init
11216 exit( tan(0.25 * ~NI_MATH_PI) )
11217 end on
11218 )NKSP_CODE",
11219 .expectRealExitResult = 1.0
11220 });
11221
11222 // std unit tests ...
11223
11224 runScript({
11225 .code = R"NKSP_CODE(
11226 on init
11227 exit( tan(0.0ms) )
11228 end on
11229 )NKSP_CODE",
11230 .expectRealExitResult = 0.0,
11231 .expectExitResultUnitPrefix = { VM_MILLI },
11232 .expectExitResultUnit = VM_SECOND
11233 });
11234
11235 runScript({
11236 .code = R"NKSP_CODE(
11237 on init
11238 exit( tan(0.0kHz) )
11239 end on
11240 )NKSP_CODE",
11241 .expectRealExitResult = 0.0,
11242 .expectExitResultUnitPrefix = { VM_KILO },
11243 .expectExitResultUnit = VM_HERTZ
11244 });
11245
11246 // 'final' ('!') operator tests ...
11247
11248 runScript({
11249 .code = R"NKSP_CODE(
11250 on init
11251 exit( tan(0.0) )
11252 end on
11253 )NKSP_CODE",
11254 .expectRealExitResult = 0.0,
11255 .expectExitResultFinal = false
11256 });
11257
11258 runScript({
11259 .code = R"NKSP_CODE(
11260 on init
11261 exit( tan(!0.0) )
11262 end on
11263 )NKSP_CODE",
11264 .expectRealExitResult = 0.0,
11265 .expectExitResultFinal = true
11266 });
11267
11268 #if !SILENT_TEST
11269 std::cout << std::endl;
11270 #endif
11271 }
11272
11273 static void testBuiltInAsinFunction() {
11274 #if !SILENT_TEST
11275 std::cout << "UNIT TEST: built-in asin() function\n";
11276 #endif
11277
11278 // integer tests ...
11279 // (ATM not allowed for this function)
11280
11281 runScript({
11282 .code = R"NKSP_CODE(
11283 on init
11284 declare $foo := 1
11285 exit( asin($foo) )
11286 end on
11287 )NKSP_CODE",
11288 .expectParseError = true // integer not allowed for this function ATM
11289 });
11290
11291 // real number tests ...
11292
11293 runScript({
11294 .code = R"NKSP_CODE(
11295 on init
11296 exit( asin(0.0) )
11297 end on
11298 )NKSP_CODE",
11299 .expectRealExitResult = 0.0
11300 });
11301
11302 runScript({
11303 .code = R"NKSP_CODE(
11304 on init
11305 exit( asin(1.0) )
11306 end on
11307 )NKSP_CODE",
11308 .expectRealExitResult = 0.5 * M_PI
11309 });
11310
11311 runScript({
11312 .code = R"NKSP_CODE(
11313 on init
11314 exit( asin(-1.0) )
11315 end on
11316 )NKSP_CODE",
11317 .expectRealExitResult = -0.5 * M_PI
11318 });
11319
11320 // std unit tests ...
11321
11322 runScript({
11323 .code = R"NKSP_CODE(
11324 on init
11325 exit( asin(0.0ms) )
11326 end on
11327 )NKSP_CODE",
11328 .expectRealExitResult = 0.0,
11329 .expectExitResultUnitPrefix = { VM_MILLI },
11330 .expectExitResultUnit = VM_SECOND
11331 });
11332
11333 runScript({
11334 .code = R"NKSP_CODE(
11335 on init
11336 exit( asin(0.0kHz) )
11337 end on
11338 )NKSP_CODE",
11339 .expectRealExitResult = 0.0,
11340 .expectExitResultUnitPrefix = { VM_KILO },
11341 .expectExitResultUnit = VM_HERTZ
11342 });
11343
11344 // 'final' ('!') operator tests ...
11345
11346 runScript({
11347 .code = R"NKSP_CODE(
11348 on init
11349 exit( asin(0.0) )
11350 end on
11351 )NKSP_CODE",
11352 .expectRealExitResult = 0.0,
11353 .expectExitResultFinal = false
11354 });
11355
11356 runScript({
11357 .code = R"NKSP_CODE(
11358 on init
11359 exit( asin(!0.0) )
11360 end on
11361 )NKSP_CODE",
11362 .expectRealExitResult = 0.0,
11363 .expectExitResultFinal = true
11364 });
11365
11366 #if !SILENT_TEST
11367 std::cout << std::endl;
11368 #endif
11369 }
11370
11371 static void testBuiltInAcosFunction() {
11372 #if !SILENT_TEST
11373 std::cout << "UNIT TEST: built-in acos() function\n";
11374 #endif
11375
11376 // integer tests ...
11377 // (ATM not allowed for this function)
11378
11379 runScript({
11380 .code = R"NKSP_CODE(
11381 on init
11382 declare $foo := 1
11383 exit( acos($foo) )
11384 end on
11385 )NKSP_CODE",
11386 .expectParseError = true // integer not allowed for this function ATM
11387 });
11388
11389 // real number tests ...
11390
11391 runScript({
11392 .code = R"NKSP_CODE(
11393 on init
11394 exit( acos(1.0) )
11395 end on
11396 )NKSP_CODE",
11397 .expectRealExitResult = 0.0
11398 });
11399
11400 runScript({
11401 .code = R"NKSP_CODE(
11402 on init
11403 exit( acos(0.0) )
11404 end on
11405 )NKSP_CODE",
11406 .expectRealExitResult = 0.5 * M_PI
11407 });
11408
11409 runScript({
11410 .code = R"NKSP_CODE(
11411 on init
11412 exit( acos(-1.0) )
11413 end on
11414 )NKSP_CODE",
11415 .expectRealExitResult = M_PI
11416 });
11417
11418 // std unit tests ...
11419
11420 runScript({
11421 .code = R"NKSP_CODE(
11422 on init
11423 exit( acos(1.0ms) )
11424 end on
11425 )NKSP_CODE",
11426 .expectRealExitResult = 0.0,
11427 .expectExitResultUnitPrefix = { VM_MILLI },
11428 .expectExitResultUnit = VM_SECOND
11429 });
11430
11431 runScript({
11432 .code = R"NKSP_CODE(
11433 on init
11434 exit( acos(1.0kHz) )
11435 end on
11436 )NKSP_CODE",
11437 .expectRealExitResult = 0.0,
11438 .expectExitResultUnitPrefix = { VM_KILO },
11439 .expectExitResultUnit = VM_HERTZ
11440 });
11441
11442 // 'final' ('!') operator tests ...
11443
11444 runScript({
11445 .code = R"NKSP_CODE(
11446 on init
11447 exit( acos(1.0) )
11448 end on
11449 )NKSP_CODE",
11450 .expectRealExitResult = 0.0,
11451 .expectExitResultFinal = false
11452 });
11453
11454 runScript({
11455 .code = R"NKSP_CODE(
11456 on init
11457 exit( acos(!1.0) )
11458 end on
11459 )NKSP_CODE",
11460 .expectRealExitResult = 0.0,
11461 .expectExitResultFinal = true
11462 });
11463
11464 #if !SILENT_TEST
11465 std::cout << std::endl;
11466 #endif
11467 }
11468
11469 static void testBuiltInAtanFunction() {
11470 #if !SILENT_TEST
11471 std::cout << "UNIT TEST: built-in atan() function\n";
11472 #endif
11473
11474 // integer tests ...
11475 // (ATM not allowed for this function)
11476
11477 runScript({
11478 .code = R"NKSP_CODE(
11479 on init
11480 declare $foo := 1
11481 exit( atan($foo) )
11482 end on
11483 )NKSP_CODE",
11484 .expectParseError = true // integer not allowed for this function ATM
11485 });
11486
11487 // real number tests ...
11488
11489 runScript({
11490 .code = R"NKSP_CODE(
11491 on init
11492 exit( atan(0.0) )
11493 end on
11494 )NKSP_CODE",
11495 .expectRealExitResult = 0.0
11496 });
11497
11498 runScript({
11499 .code = R"NKSP_CODE(
11500 on init
11501 exit( atan(1.0) )
11502 end on
11503 )NKSP_CODE",
11504 .expectRealExitResult = 0.25 * M_PI
11505 });
11506
11507 // std unit tests ...
11508
11509 runScript({
11510 .code = R"NKSP_CODE(
11511 on init
11512 exit( atan(0.0ms) )
11513 end on
11514 )NKSP_CODE",
11515 .expectRealExitResult = 0.0,
11516 .expectExitResultUnitPrefix = { VM_MILLI },
11517 .expectExitResultUnit = VM_SECOND
11518 });
11519
11520 runScript({
11521 .code = R"NKSP_CODE(
11522 on init
11523 exit( atan(0.0kHz) )
11524 end on
11525 )NKSP_CODE",
11526 .expectRealExitResult = 0.0,
11527 .expectExitResultUnitPrefix = { VM_KILO },
11528 .expectExitResultUnit = VM_HERTZ
11529 });
11530
11531 // 'final' ('!') operator tests ...
11532
11533 runScript({
11534 .code = R"NKSP_CODE(
11535 on init
11536 exit( atan(0.0) )
11537 end on
11538 )NKSP_CODE",
11539 .expectRealExitResult = 0.0,
11540 .expectExitResultFinal = false
11541 });
11542
11543 runScript({
11544 .code = R"NKSP_CODE(
11545 on init
11546 exit( atan(!0.0) )
11547 end on
11548 )NKSP_CODE",
11549 .expectRealExitResult = 0.0,
11550 .expectExitResultFinal = true
11551 });
11552
11553 #if !SILENT_TEST
11554 std::cout << std::endl;
11555 #endif
11556 }
11557
11558 static void testBuiltInNumElementsFunction() {
11559 #if !SILENT_TEST
11560 std::cout << "UNIT TEST: built-in num_elements() function\n";
11561 #endif
11562
11563 // integer array tests ...
11564
11565 runScript({
11566 .code = R"NKSP_CODE(
11567 on init
11568 declare %foo[3] := ( 19, 3, 6 )
11569 exit( num_elements(%foo) )
11570 end on
11571 )NKSP_CODE",
11572 .expectIntExitResult = 3
11573 });
11574
11575 runScript({
11576 .code = R"NKSP_CODE(
11577 on init
11578 declare %foo[1] := ( 19 )
11579 exit( num_elements(%foo) )
11580 end on
11581 )NKSP_CODE",
11582 .expectIntExitResult = 1
11583 });
11584
11585 runScript({
11586 .code = R"NKSP_CODE(
11587 on init
11588 declare %foo[5] := ( 1, 2, 3, 4, 5 )
11589 exit( num_elements(%foo) )
11590 end on
11591 )NKSP_CODE",
11592 .expectIntExitResult = 5
11593 });
11594
11595 // real array tests ...
11596
11597 runScript({
11598 .code = R"NKSP_CODE(
11599 on init
11600 declare ?foo[3] := ( 19.0, 3.2, 6.5 )
11601 exit( num_elements(?foo) )
11602 end on
11603 )NKSP_CODE",
11604 .expectIntExitResult = 3
11605 });
11606
11607 runScript({
11608 .code = R"NKSP_CODE(
11609 on init
11610 declare ?foo[1] := ( 19.0 )
11611 exit( num_elements(?foo) )
11612 end on
11613 )NKSP_CODE",
11614 .expectIntExitResult = 1
11615 });
11616
11617 runScript({
11618 .code = R"NKSP_CODE(
11619 on init
11620 declare ?foo[5] := ( 1.1, 2.2, 3.3, 4.4, 5.5 )
11621 exit( num_elements(?foo) )
11622 end on
11623 )NKSP_CODE",
11624 .expectIntExitResult = 5
11625 });
11626
11627 #if !SILENT_TEST
11628 std::cout << std::endl;
11629 #endif
11630 }
11631
11632 static void testBuiltInSearchFunction() {
11633 #if !SILENT_TEST
11634 std::cout << "UNIT TEST: built-in search() function\n";
11635 #endif
11636
11637 // integer array tests ...
11638
11639 runScript({
11640 .code = R"NKSP_CODE(
11641 on init
11642 declare %foo[3] := ( 19, 3, 6 )
11643 exit( search(%foo, 19) )
11644 end on
11645 )NKSP_CODE",
11646 .expectIntExitResult = 0
11647 });
11648
11649 runScript({
11650 .code = R"NKSP_CODE(
11651 on init
11652 declare %foo[3] := ( 19, 3, 6 )
11653 exit( search(%foo, 3) )
11654 end on
11655 )NKSP_CODE",
11656 .expectIntExitResult = 1
11657 });
11658
11659 runScript({
11660 .code = R"NKSP_CODE(
11661 on init
11662 declare %foo[3] := ( 19, 3, 6 )
11663 exit( search(%foo, 6) )
11664 end on
11665 )NKSP_CODE",
11666 .expectIntExitResult = 2
11667 });
11668
11669 runScript({
11670 .code = R"NKSP_CODE(
11671 on init
11672 declare %foo[3] := ( 19, 3, 6 )
11673 exit( search(%foo, 2) )
11674 end on
11675 )NKSP_CODE",
11676 .expectIntExitResult = -1
11677 });
11678
11679 // real array tests ...
11680
11681 runScript({
11682 .code = R"NKSP_CODE(
11683 on init
11684 declare ?foo[3] := ( 19.12, 3.45, 6.89 )
11685 exit( search(?foo, 19.12) )
11686 end on
11687 )NKSP_CODE",
11688 .expectIntExitResult = 0
11689 });
11690
11691 runScript({
11692 .code = R"NKSP_CODE(
11693 on init
11694 declare ?foo[3] := ( 19.12, 3.45, 6.89 )
11695 exit( search(?foo, 3.45) )
11696 end on
11697 )NKSP_CODE",
11698 .expectIntExitResult = 1
11699 });
11700
11701 runScript({
11702 .code = R"NKSP_CODE(
11703 on init
11704 declare ?foo[3] := ( 19.12, 3.45, 6.89 )
11705 exit( search(?foo, 6.89) )
11706 end on
11707 )NKSP_CODE",
11708 .expectIntExitResult = 2
11709 });
11710
11711 runScript({
11712 .code = R"NKSP_CODE(
11713 on init
11714 declare ?foo[3] := ( 19.12, 3.45, 6.89 )
11715 exit( search(?foo, 6.99) )
11716 end on
11717 )NKSP_CODE",
11718 .expectIntExitResult = -1
11719 });
11720
11721 #if !SILENT_TEST
11722 std::cout << std::endl;
11723 #endif
11724 }
11725
11726 static void testIfStatement() {
11727 #if !SILENT_TEST
11728 std::cout << "UNIT TEST: if statement\n";
11729 #endif
11730
11731 runScript({
11732 .code = R"NKSP_CODE(
11733 on init
11734 declare $foo := 1
11735 if ($foo)
11736 exit(42)
11737 end if
11738 end on
11739 )NKSP_CODE",
11740 .expectIntExitResult = 42
11741 });
11742
11743 runScript({
11744 .code = R"NKSP_CODE(
11745 on init
11746 declare $foo := 0
11747 if ($foo)
11748 exit(42)
11749 end if
11750 exit(3)
11751 end on
11752 )NKSP_CODE",
11753 .expectIntExitResult = 3
11754 });
11755
11756 runScript({
11757 .code = R"NKSP_CODE(
11758 on init
11759 declare $foo := 1
11760 if ($foo)
11761 exit(42)
11762 else
11763 exit(3)
11764 end if
11765 end on
11766 )NKSP_CODE",
11767 .expectIntExitResult = 42
11768 });
11769
11770 runScript({
11771 .code = R"NKSP_CODE(
11772 on init
11773 declare $foo := 0
11774 if ($foo)
11775 exit(42)
11776 else
11777 exit(3)
11778 end if
11779 end on
11780 )NKSP_CODE",
11781 .expectIntExitResult = 3
11782 });
11783
11784 #if !SILENT_TEST
11785 std::cout << std::endl;
11786 #endif
11787 }
11788
11789 static void testWhileStatement() {
11790 #if !SILENT_TEST
11791 std::cout << "UNIT TEST: while statement\n";
11792 #endif
11793
11794 runScript({
11795 .code = R"NKSP_CODE(
11796 on init
11797 declare $foo := 100
11798 declare $i := 50
11799 while ($i)
11800 $foo := $foo + 1
11801 $i := $i - 1
11802 end while
11803 exit($foo)
11804 end on
11805 )NKSP_CODE",
11806 .expectIntExitResult = 150
11807 });
11808
11809 #if !SILENT_TEST
11810 std::cout << std::endl;
11811 #endif
11812 }
11813
11814 static void testBuiltInVars() {
11815 #if !SILENT_TEST
11816 std::cout << "UNIT TEST: built-in variables\n";
11817 #endif
11818
11819 runScript({
11820 .code = R"NKSP_CODE(
11821 on init
11822 exit($NKSP_PERF_TIMER)
11823 end on
11824 )NKSP_CODE",
11825 .expectExitResultIsInt = true,
11826 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
11827 .expectExitResultUnit = VM_NO_UNIT
11828 });
11829
11830 runScript({
11831 .code = R"NKSP_CODE(
11832 on init
11833 exit($NKSP_REAL_TIMER)
11834 end on
11835 )NKSP_CODE",
11836 .expectExitResultIsInt = true,
11837 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
11838 .expectExitResultUnit = VM_NO_UNIT
11839 });
11840
11841 runScript({
11842 .code = R"NKSP_CODE(
11843 on init
11844 exit($KSP_TIMER)
11845 end on
11846 )NKSP_CODE",
11847 .expectExitResultIsInt = true,
11848 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
11849 .expectExitResultUnit = VM_NO_UNIT
11850 });
11851
11852 runScript({
11853 .code = R"NKSP_CODE(
11854 on init
11855 exit(~NI_MATH_PI)
11856 end on
11857 )NKSP_CODE",
11858 .expectExitResultIsReal = true,
11859 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
11860 .expectExitResultUnit = VM_NO_UNIT
11861 });
11862
11863 runScript({
11864 .code = R"NKSP_CODE(
11865 on init
11866 exit(~NI_MATH_E)
11867 end on
11868 )NKSP_CODE",
11869 .expectExitResultIsReal = true,
11870 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
11871 .expectExitResultUnit = VM_NO_UNIT
11872 });
11873
11874 runScript({
11875 .code = R"NKSP_CODE(
11876 on init
11877 exit($NI_CB_TYPE_INIT)
11878 end on
11879 )NKSP_CODE",
11880 .expectIntExitResult = VM_EVENT_HANDLER_INIT,
11881 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
11882 .expectExitResultUnit = VM_NO_UNIT
11883 });
11884
11885 runScript({
11886 .code = R"NKSP_CODE(
11887 on init
11888 exit($NI_CB_TYPE_NOTE)
11889 end on
11890 )NKSP_CODE",
11891 .expectIntExitResult = VM_EVENT_HANDLER_NOTE,
11892 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
11893 .expectExitResultUnit = VM_NO_UNIT
11894 });
11895
11896 runScript({
11897 .code = R"NKSP_CODE(
11898 on init
11899 exit($NI_CB_TYPE_RELEASE)
11900 end on
11901 )NKSP_CODE",
11902 .expectIntExitResult = VM_EVENT_HANDLER_RELEASE,
11903 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
11904 .expectExitResultUnit = VM_NO_UNIT
11905 });
11906
11907 runScript({
11908 .code = R"NKSP_CODE(
11909 on init
11910 exit($NI_CB_TYPE_CONTROLLER)
11911 end on
11912 )NKSP_CODE",
11913 .expectIntExitResult = VM_EVENT_HANDLER_CONTROLLER,
11914 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
11915 .expectExitResultUnit = VM_NO_UNIT
11916 });
11917
11918 runScript({
11919 .code = R"NKSP_CODE(
11920 on init
11921 exit($NI_CB_TYPE_RPN)
11922 end on
11923 )NKSP_CODE",
11924 .expectIntExitResult = VM_EVENT_HANDLER_RPN,
11925 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
11926 .expectExitResultUnit = VM_NO_UNIT
11927 });
11928
11929 runScript({
11930 .code = R"NKSP_CODE(
11931 on init
11932 exit($NI_CB_TYPE_NRPN)
11933 end on
11934 )NKSP_CODE",
11935 .expectIntExitResult = VM_EVENT_HANDLER_NRPN,
11936 .expectExitResultUnitPrefix = { VM_NO_PREFIX },
11937 .expectExitResultUnit = VM_NO_UNIT
11938 });
11939
11940 #if !SILENT_TEST
11941 std::cout << std::endl;
11942 #endif
11943 }
11944
11945 #if !NO_MAIN
11946
11947 int main() {
11948 testBuiltInExitFunction();
11949 testStringConcatOperator();
11950 testNegOperator();
11951 testPlusOperator();
11952 testMinusOperator();
11953 testModuloOperator();
11954 testMultiplyOperator();
11955 testDivideOperator();
11956 testSmallerThanOperator();
11957 testGreaterThanOperator();
11958 testSmallerOrEqualOperator();
11959 testGreaterOrEqualOperator();
11960 testEqualOperator();
11961 testUnequalOperator();
11962 testLogicalAndOperator();
11963 testLogicalOrOperator();
11964 testLogicalNotOperator();
11965 testBitwiseAndOperator();
11966 testBitwiseOrOperator();
11967 testBitwiseNotOperator();
11968 testPrecedenceOfOperators();
11969 testIntVarDeclaration();
11970 testIntArrayVarDeclaration();
11971 testRealVarDeclaration();
11972 testRealArrayVarDeclaration();
11973 testStringVarDeclaration();
11974 testBuiltInMinFunction();
11975 testBuiltInMaxFunction();
11976 testBuiltInAbsFunction();
11977 testBuiltInIncFunction();
11978 testBuiltInDecFunction();
11979 testBuiltInInRangeFunction();
11980 testBuiltInRandomFunction();
11981 testBuiltInShiftLeftFunction();
11982 testBuiltInShiftRightFunction();
11983 testBuiltInMsbFunction();
11984 testBuiltInLsbFunction();
11985 testBuiltInIntToRealFunction();
11986 testBuiltInRealFunction();
11987 testBuiltInRealToIntFunction();
11988 testBuiltInIntFunction();
11989 testBuiltInRoundFunction();
11990 testBuiltInCeilFunction();
11991 testBuiltInFloorFunction();
11992 testBuiltInSqrtFunction();
11993 testBuiltInLogFunction();
11994 testBuiltInLog2Function();
11995 testBuiltInLog10Function();
11996 testBuiltInExpFunction();
11997 testBuiltInPowFunction();
11998 testBuiltInSinFunction();
11999 testBuiltInCosFunction();
12000 testBuiltInTanFunction();
12001 testBuiltInAsinFunction();
12002 testBuiltInAcosFunction();
12003 testBuiltInAtanFunction();
12004 testBuiltInArrayEqualFunction();
12005 testBuiltInSortFunction();
12006 testBuiltInNumElementsFunction();
12007 testBuiltInSearchFunction();
12008 testIfStatement();
12009 testWhileStatement();
12010 testBuiltInVars();
12011 std::cout << "\nAll tests passed successfully. :-)\n";
12012 return 0;
12013 }
12014
12015 #endif // !NO_MAIN

  ViewVC Help
Powered by ViewVC