diff options
Diffstat (limited to 'tests/custom/03_stdlib')
50 files changed, 4180 insertions, 0 deletions
diff --git a/tests/custom/03_stdlib/01_chr b/tests/custom/03_stdlib/01_chr new file mode 100644 index 0000000..17163e3 --- /dev/null +++ b/tests/custom/03_stdlib/01_chr @@ -0,0 +1,27 @@ +The `chr()` function converts each given numeric value into a character +and returns the resulting string, e.g. passing 97, 98 and 99 will yield +the string `abc`. + +Negative numeric values and values which cannot be converted to integers +are treated as `0`, values larger than `255` are capped to `255`. + +The resulting string will have the same length as the amount of arguments +passed to the `chr()` function. + +-- Testcase -- +{% + printf("%.J\n", [ + chr(), + chr(97, 98, 99), + chr(-1, false, null, [], {}, "0x41", 66.5, 1000) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "", + "abc", + "\u0000\u0000\u0000\u0000\u0000AB\u00ff" +] +-- End -- diff --git a/tests/custom/03_stdlib/02_die b/tests/custom/03_stdlib/02_die new file mode 100644 index 0000000..344069a --- /dev/null +++ b/tests/custom/03_stdlib/02_die @@ -0,0 +1,49 @@ +The `die()` function triggers a user defined runtime exception when invoked, +using the given value as exception message. + +The given message value is converted to a string internally if it is not a +string already. If no message argument is given or if the message argument +is `null`, the default message is `Died`. + +The function does not return. + +-- Testcase -- +{% + print("Before invoking die()\n"); + + die("An exception!"); + + print("After invoking die()\n"); +%} +-- End -- + +-- Expect stdout -- +Before invoking die() +-- End -- + +-- Expect stderr -- +An exception! +In line 4, byte 21: + + ` die("An exception!");` + Near here -------------^ + + +-- End -- + + +-- Testcase -- +{% + die(); +%} +-- End -- + +-- Expect stderr -- +Died +In line 2, byte 6: + + ` die();` + ^-- Near here + + +-- End -- diff --git a/tests/custom/03_stdlib/03_exists b/tests/custom/03_stdlib/03_exists new file mode 100644 index 0000000..3d71aa7 --- /dev/null +++ b/tests/custom/03_stdlib/03_exists @@ -0,0 +1,38 @@ +The `exists()` function checks the existence of the given key within the +given object. If the object contains the given key, `true` is returned, +otherwise `false`. + +If the object argument is not an object, `false` is returned as well. + +The key argument is converted to a string in case it is not one already. + +-- Testcase -- +{% + let obj = { + "foo": true, + "bar": false, + "false": null, + "123": "a number" + }; + + printf("%.J\n", [ + exists(true, "test"), + exists(obj, "doesnotexists"), + exists(obj, "foo"), + exists(obj, "bar"), + exists(obj, !true), + exists(obj, 123) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + false, + false, + true, + true, + true, + true +] +-- End -- diff --git a/tests/custom/03_stdlib/04_exit b/tests/custom/03_stdlib/04_exit new file mode 100644 index 0000000..1f941d1 --- /dev/null +++ b/tests/custom/03_stdlib/04_exit @@ -0,0 +1,36 @@ +The `exit()` function terminates the running program with the given exit +code or 0 in case no argument is given or if the argument cannot be +converted to an integer. + +The function does not return. + +-- Testcase -- +{% + print("Before invoking exit()\n"); + + exit(); + + print("After invoking exit()\n"); +%} +-- End -- + +-- Expect stdout -- +Before invoking exit() +-- End -- + +-- Expect exitcode -- +0 +-- End -- + + +Passing a code argument overrides the default "0" value. + +-- Testcase -- +{% + exit(123) +%} +-- End -- + +-- Expect exitcode -- +123 +-- End -- diff --git a/tests/custom/03_stdlib/05_getenv b/tests/custom/03_stdlib/05_getenv new file mode 100644 index 0000000..350e952 --- /dev/null +++ b/tests/custom/03_stdlib/05_getenv @@ -0,0 +1,30 @@ +The `getenv()` function returns the value of the given environment variable +or `null` if either the given variable does not exist or if the given name +argument is not a string. + +-- Testcase -- +{% + printf("%.J\n", [ + getenv("TEST_VARIABLE"), + getenv("EMPTY_VARIABLE"), + getenv("THIS_LIKELY_DOES_NOT_EXIST"), + getenv(123), + getenv(null) + ]); +%} +-- End -- + +-- Vars -- +TEST_VARIABLE=Test Value +EMPTY_VARIABLE= +-- End -- + +-- Expect stdout -- +[ + "Test Value", + "", + null, + null, + null +] +-- End -- diff --git a/tests/custom/03_stdlib/06_filter b/tests/custom/03_stdlib/06_filter new file mode 100644 index 0000000..400db34 --- /dev/null +++ b/tests/custom/03_stdlib/06_filter @@ -0,0 +1,113 @@ +The `filter()` function filters the given array by invoking the specified +callback for each item of the input array and only keeping items for which +the callback returned a truish value. + +Returns the filtered copy of the input array, maintaining the original order +of items. The input array is not modified. + +Returns `null` if the first argument is not an array. + +-- Testcase -- +{% + let numbers = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]; + + printf("%.J\n", + filter(numbers, function(n) { + return (n % 2) == 0; + }) + ); +%} +-- End -- + +-- Expect stdout -- +[ + 0, + 2, + 4, + 6, + 8 +] +-- End -- + + +Supplying an invalid callback will trigger an exception. + +-- Testcase -- +{% + filter([1, 2, 3], "not_a_function") +%} +-- End -- + +-- Expect stderr -- +Type error: left-hand side is not a function +In line 2, byte 36: + + ` filter([1, 2, 3], "not_a_function")` + Near here ----------------------------^ + + +-- End -- + + +Supplying an invalid array will yield `null`. + +-- Testcase -- +{% + printf("%.J\n", filter("not_an_array", function(i) { return i > 3 })); +%} +-- End -- + +-- Expect stdout -- +null +-- End -- + + +The callback is invoked with three argument for each item, the current item +value, the index position of the item and the input array being mapped. + +-- Testcase -- +{% + let words = [ "foo", "bar", "baz", "qrx" ]; + + print(join("\n", + filter(words, function(word, idx, src) { + printf("word=%s, idx=%d, src=%J\n", word, idx, src); + + return true; + }) + ), "\n"); +%} +-- End -- + +-- Expect stdout -- +word=foo, idx=0, src=[ "foo", "bar", "baz", "qrx" ] +word=bar, idx=1, src=[ "foo", "bar", "baz", "qrx" ] +word=baz, idx=2, src=[ "foo", "bar", "baz", "qrx" ] +word=qrx, idx=3, src=[ "foo", "bar", "baz", "qrx" ] +foo +bar +baz +qrx +-- End -- + + +Exceptions in the callback terminate the filter process and are +propagated to the calling context. + +-- Testcase -- +{% + filter([ 1, 2, 3 ], function() { die() }); +%} +-- End -- + +-- Expect stderr -- +Died +In [anonymous function](), line 2, byte 39: + called from function filter ([C]) + called from anonymous function ([stdin]:2:42) + + ` filter([ 1, 2, 3 ], function() { die() });` + Near here -------------------------------^ + + +-- End -- diff --git a/tests/custom/03_stdlib/07_hex b/tests/custom/03_stdlib/07_hex new file mode 100644 index 0000000..419970c --- /dev/null +++ b/tests/custom/03_stdlib/07_hex @@ -0,0 +1,33 @@ +The `hex()` function converts the given hexadecimal string into a signed +integer value and returns the resulting number. + +Returns `NaN` if the given argument is not a string, an empty string or +a string containing non-hexadecimal digits. + +-- Testcase -- +{% + printf("%.J\n", [ + hex(), + hex(false), + hex(123), + hex(""), + hex("invalid"), + hex("deaf"), + hex("0x1000"), + hex("ffffffffffffffff") + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "NaN", + "NaN", + "NaN", + "NaN", + "NaN", + 57007, + 4096, + 9223372036854775807 +] +-- End -- diff --git a/tests/custom/03_stdlib/08_int b/tests/custom/03_stdlib/08_int new file mode 100644 index 0000000..a6b5923 --- /dev/null +++ b/tests/custom/03_stdlib/08_int @@ -0,0 +1,42 @@ +The `int()` function converts the given value into a signed integer +value and returns the resulting number. + +Returns `NaN` if the given argument is not convertible into a number. + +Returns `NaN` if the conversion result is out of range. + +-- Testcase -- +{% + printf("%.J\n", [ + int(), + int(false), + int(123), + int(456.789), + int(""), + int("invalid"), + int("deaf"), + int("0x1000"), + int("0xffffffffffffffff"), + int("0177"), + int("+145"), + int("-96") + ]); +%} +-- End -- + +-- Expect stdout -- +[ + 0, + 0, + 123, + 456, + 0, + "NaN", + "NaN", + 4096, + "NaN", + 127, + "NaN", + -96 +] +-- End -- diff --git a/tests/custom/03_stdlib/09_join b/tests/custom/03_stdlib/09_join new file mode 100644 index 0000000..dac49c3 --- /dev/null +++ b/tests/custom/03_stdlib/09_join @@ -0,0 +1,31 @@ +The `join()` function constructs a string out of the given array by +converting each array item into a string and then joining these substrings +putting the given separator value in between. An empty array will result in +an empty string. + +The separator argument is converted into a string in case it is not already +a string value. + +Returns `null` if the given array argument is not an array value. + +-- Testcase -- +{% + printf("%.J\n", [ + join("|", []), + join("|", [ 1, 2, 3 ]), + join("|", [ null, false, "" ]), + join(123, [ "a", "b", "c" ]), + join(123, { "not": "an", "array": "value" }) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "", + "1|2|3", + "null|false|", + "a123b123c", + null +] +-- End -- diff --git a/tests/custom/03_stdlib/10_keys b/tests/custom/03_stdlib/10_keys new file mode 100644 index 0000000..46462a0 --- /dev/null +++ b/tests/custom/03_stdlib/10_keys @@ -0,0 +1,21 @@ +The `keys()` function returns an array containing all keys of the given +dictionary value. The keys are sorted in declaration order. + +-- Testcase -- +{{ keys({ "foo": true, "bar": false, "qrx": 123 }) }} +-- End -- + +-- Expect stdout -- +[ "foo", "bar", "qrx" ] +-- End -- + + +If the given argument is not a dictionary, the function returns `null`. + +-- Testcase -- +{{ keys(true) === null }} +-- End -- + +-- Expect stdout -- +true +-- End -- diff --git a/tests/custom/03_stdlib/11_lc b/tests/custom/03_stdlib/11_lc new file mode 100644 index 0000000..1ae3cb1 --- /dev/null +++ b/tests/custom/03_stdlib/11_lc @@ -0,0 +1,27 @@ +The `lc()` function turns each upper case character in the source string +into lower case and returns the resulting copy. + +The input argument is converted to a string in case it is not already a +string value. + +-- Testcase -- +{% + printf("%.J\n", [ + lc("This Will Be All Lowercased."), + lc([ "An", "array", "ABC" ]), + lc(123), + lc(false), + lc() + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "this will be all lowercased.", + "[ \"an\", \"array\", \"abc\" ]", + "123", + "false", + "null" +] +-- End -- diff --git a/tests/custom/03_stdlib/12_map b/tests/custom/03_stdlib/12_map new file mode 100644 index 0000000..508838d --- /dev/null +++ b/tests/custom/03_stdlib/12_map @@ -0,0 +1,111 @@ +The `map()` function creates a new array from the given input array by +invoking the specified callback for each item of the input array and +putting the resulting return value into the new array. + +Returns the newly created array. The input array is not modified. + +Returns `null` if the first argument is not an array. + +-- Testcase -- +{% + let numbers = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]; + + printf("%.J\n", + map(numbers, function(n) { + return (n * n); + }) + ); +%} +-- End -- + +-- Expect stdout -- +[ + 0, + 1, + 4, + 9, + 16, + 25, + 36, + 49, + 64, + 81 +] +-- End -- + + +Supplying an invalid callback will trigger an exception. + +-- Testcase -- +{% + map([1, 2, 3], "not_a_function") +%} +-- End -- + +-- Expect stderr -- +Type error: left-hand side is not a function +In line 2, byte 33: + + ` map([1, 2, 3], "not_a_function")` + Near here -------------------------^ + + +-- End -- + + +Supplying an invalid array will yield `null`. + +-- Testcase -- +{% + printf("%.J\n", map("not_an_array", function(i) { return i > 3 })); +%} +-- End -- + +-- Expect stdout -- +null +-- End -- + + +The callback is invoked with three argument for each item, the current item +value, the index position of the item and the input array being mapped. + +-- Testcase -- +{% + let words = [ "foo", "bar", "baz", "qrx" ]; + + print(join("\n", + map(words, function(word, idx, src) { + return sprintf("word=%s, idx=%d, src=%J", word, idx, src); + }) + ), "\n"); +%} +-- End -- + +-- Expect stdout -- +word=foo, idx=0, src=[ "foo", "bar", "baz", "qrx" ] +word=bar, idx=1, src=[ "foo", "bar", "baz", "qrx" ] +word=baz, idx=2, src=[ "foo", "bar", "baz", "qrx" ] +word=qrx, idx=3, src=[ "foo", "bar", "baz", "qrx" ] +-- End -- + + +Exceptions in the callback terminate the map process and are +propagated to the calling context. + +-- Testcase -- +{% + map([ 1, 2, 3 ], function() { die() }); +%} +-- End -- + +-- Expect stderr -- +Died +In [anonymous function](), line 2, byte 36: + called from function map ([C]) + called from anonymous function ([stdin]:2:39) + + ` map([ 1, 2, 3 ], function() { die() });` + Near here ----------------------------^ + + +-- End -- diff --git a/tests/custom/03_stdlib/13_ord b/tests/custom/03_stdlib/13_ord new file mode 100644 index 0000000..3a69228 --- /dev/null +++ b/tests/custom/03_stdlib/13_ord @@ -0,0 +1,46 @@ +The `ord()` function extracts the byte values of characters within the +given input string at different offsets, depending on the arguments. + +Without further arguments, the function will return the byte value of +the first character within the given string. + +If one or more offset arguments are given, the function returns an array +containing the byte values of each character at the corresponding offset. + +Returns `null` if the given input string argument is not a string. + +Returns `null` if the given input string is empty and no offset arguments +are provided. + +If invalid offsets are given, the corresponding values within the result +array will be set to `null`. + +Invalid offsets are non-integer values or integers equal to or larger than +the length of the input string. Negative offsets are converted to positive +ones by adding the length of the input string. If the negative value is +too large, the offset is considered invalid. + + +-- Testcase -- +{% + print(join("\n", [ + ord(123), + ord(""), + ord("abcd"), + ord("abcd", 0), + ord("abcd", 1, 3, 2), + ord("abcd", -1, -2), + ord("abcd", -10, 10) + ]), "\n"); +%} +-- End -- + +-- Expect stdout -- +null +null +97 +[ 97 ] +[ 98, 100, 99 ] +[ 100, 99 ] +[ null, null ] +-- End -- diff --git a/tests/custom/03_stdlib/14_type b/tests/custom/03_stdlib/14_type new file mode 100644 index 0000000..243618e --- /dev/null +++ b/tests/custom/03_stdlib/14_type @@ -0,0 +1,43 @@ +The `type()` function returns the type name of the given argument as +string. + +Returns `null` if the given argument is `null` or omitted. + + +-- Testcase -- +{% + printf("%.J\n", [ + type(), + type(null), + type(false), + type(true), + type(123), + type(-0xaf), + type(456.789), + type(-456.789), + type([ "foo", "bar", "baz" ]), + type({ example: "object" }), + type(function() {}), + type((n) => n * n), + type(print) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + null, + null, + "bool", + "bool", + "int", + "int", + "double", + "double", + "array", + "object", + "function", + "function", + "function" +] +-- End -- diff --git a/tests/custom/03_stdlib/15_reverse b/tests/custom/03_stdlib/15_reverse new file mode 100644 index 0000000..176cd4c --- /dev/null +++ b/tests/custom/03_stdlib/15_reverse @@ -0,0 +1,31 @@ +The `reverse()` function returns the input argument in reverse order. + +Returns a reversed copy of the input string if the given input value +argument is a string. + +Returns a reversed copy of the input array if the given input value +argument is an array. + +Returns `null` if the input argument is neither a string nor an array. + +-- Testcase -- +{% + printf("%.J\n", [ + reverse("abc"), + reverse([1, 2, 3]), + reverse(true) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "cba", + [ + 3, + 2, + 1 + ], + null +] +-- End -- diff --git a/tests/custom/03_stdlib/16_sort b/tests/custom/03_stdlib/16_sort new file mode 100644 index 0000000..ccc235f --- /dev/null +++ b/tests/custom/03_stdlib/16_sort @@ -0,0 +1,108 @@ +The `sort()` function performs an in-place sorting on the given array, +invoking the specified callback (if any) to compare items during the +sort process. + +If no callback is given or if the callback argument is `null`, a default +comparator function is used which will sort number values numerically +and all other value types lexically. + +Returns the sorted input array. + +Returns `null` if the given input array value is not an array. + + +-- Testcase -- +{% + print(join("\n", [ + // default numeric sort + sort([ 6, 4.3, 1, 45, 3.01, 2 ]), + + // default lexical sort + sort([ "qrx", "bar", "foo", "abc" ]), + + // default lexical sort due to implicit stringification + sort([ true, false, null, 1, "2b" ]), + + // sort with custom callback (by word length) + sort([ "apple", "pear", "banana", "grapefruit" ], (a, b) => length(a) - length(b)), + + // sort with custom callback (by type, then value) + sort([ 4, 1, 9, 2, "x", "a", "q", "b" ], (a, b) => { + let t1 = type(a), t2 = type(b); + if (t1 < t2) + return -1; + else if (t2 > t2) + return 1; + + if (a < b) + return -1; + else if (a > b) + return 1; + + return 0; + }) + ]), "\n"); +%} +-- End -- + +-- Expect stdout -- +[ 1, 2, 3.01, 4.3, 6, 45 ] +[ "abc", "bar", "foo", "qrx" ] +[ 1, "2b", false, null, true ] +[ "pear", "apple", "banana", "grapefruit" ] +[ 1, 2, 4, 9, "a", "b", "q", "x" ] +-- End -- + + +Supplying an invalid callback will trigger an exception. + +-- Testcase -- +{% + sort([3, 1, 2], "not_a_function") +%} +-- End -- + +-- Expect stderr -- +Type error: left-hand side is not a function +In line 2, byte 34: + + ` sort([3, 1, 2], "not_a_function")` + Near here --------------------------^ + + +-- End -- + + +Supplying an invalid array will yield `null`. + +-- Testcase -- +{% + printf("%.J\n", sort("not_an_array", function(a, b) { return a - b })); +%} +-- End -- + +-- Expect stdout -- +null +-- End -- + + +Exceptions in the callback terminate the sort process and are +propagated to the calling context. + +-- Testcase -- +{% + sort([ 1, 2, 3 ], function() { die() }); +%} +-- End -- + +-- Expect stderr -- +Died +In [anonymous function](), line 2, byte 37: + called from function sort ([C]) + called from anonymous function ([stdin]:2:40) + + ` sort([ 1, 2, 3 ], function() { die() });` + Near here -----------------------------^ + + +-- End -- diff --git a/tests/custom/03_stdlib/17_splice b/tests/custom/03_stdlib/17_splice new file mode 100644 index 0000000..f8fb9a2 --- /dev/null +++ b/tests/custom/03_stdlib/17_splice @@ -0,0 +1,98 @@ +The `splice()` function performs in-place addition and removal of elements +on the given array. + +If no offset, remove count and additional items are supplied, all elements +are removed from the array. + +If just an offset, but no remove count and not additional items are given, +all elements beginning with the given offset until the end of the array +are removed. + +If at least an offset and a remove count are given, then that amount of +items are removed from the array, beginning at the specified offset. Any +further supplied additional item (if any) is inserted in the same order +beginning at the given offset. + +If either the offset or the remove count are negative, they're treated +as counting towards the end of the array. If either value exceeds the +array length, it is capped to the length of the array. + +Returns the modified input array. + +Returns `null` if the given input array value is not an array. + + +-- Testcase -- +{% + let arr = [ 6, 4.3, 1, 45, 3.01, 2 ]; + + print(join("\n", [ + // remove all items + splice([ ...arr ]), + + // remove all items from index 4 till end + splice([ ...arr ], 4), + + // remove item 2 and 3 + splice([ ...arr ], 1, 2), + + // remove last two items + splice([ ...arr ], -2), + + // remove items 4 and 5 + splice([ ...arr ], -3, -1), + + // replace item 2 + splice([ ...arr ], 1, 1, 7.9), + + // add item between 3 and 4 + splice([ ...arr ], 3, 0, 34), + + // append three items + splice([ ...arr ], length(arr), 0, 123, 456, 789) + ]), "\n"); +%} +-- End -- + +-- Expect stdout -- +[ ] +[ 6, 4.3, 1, 45 ] +[ 6, 45, 3.01, 2 ] +[ 6, 4.3, 1, 45 ] +[ 6, 4.3, 1, 2 ] +[ 6, 7.9, 1, 45, 3.01, 2 ] +[ 6, 4.3, 1, 34, 45, 3.01, 2 ] +[ 6, 4.3, 1, 45, 3.01, 2, 123, 456, 789 ] +-- End -- + + +Supplying an invalid array will yield `null`. + +-- Testcase -- +{% + printf("%.J\n", splice("not_an_array", 0, 1)); +%} +-- End -- + +-- Expect stdout -- +null +-- End -- + + +Invalid, non-numeric offset or index values are treated as 0. + +-- Testcase -- +{% + let arr = [ 6, 4.3, 1, 45, 3.01, 2 ]; + + print(join("\n", [ + splice([ ...arr ], "foo", "bar"), + splice([ ...arr ], "foo", "bar", "baz") + ]), "\n"); +%} +-- End -- + +-- Expect stdout -- +[ 6, 4.3, 1, 45, 3.01, 2 ] +[ "baz", 6, 4.3, 1, 45, 3.01, 2 ] +-- End -- diff --git a/tests/custom/03_stdlib/18_split b/tests/custom/03_stdlib/18_split new file mode 100644 index 0000000..e31ce78 --- /dev/null +++ b/tests/custom/03_stdlib/18_split @@ -0,0 +1,87 @@ +The `split()` function breaks the given string into multiple substrings, +using the given separator value. + +The separator may be either a string or a regular expression value. + +Returns an array containing the resulting parts. + +Returns `null` if the given input value is not a string or if the separator +argument is neither a string nor a regular expression. + + +-- Testcase -- +{% + print(join("\n", [ + // split by string + split("foo|bar|baz", "|"), + + // split by regexp + split("apples, bananas and strawberries are fruits", /, | and | are | /), + + // splitting an empty string yields an array containing one empty string + split("", "|"), + split("", ""), + split("", /\s+/), + + // splitting with an empty string as separator yields an array containing + // all characters individually + split("foo|bar|baz", ""), + split("foo|bar|baz", /()/), + + // splitting on a separator not found within the string will yield an + // array containing the entire string as sole element + split("foo|bar|baz", "xxx"), + split("foo|bar|baz", /\d+/), + + // subsequent separators are not coalesced + split("abc|||def", "|"), + split("foo1bar23baz", /[[:digit:]]/), + + // leading and trailing empty substrings are retained + split("|abc|def|", "|"), + split(",foo;bar:", /[,;:]/), + ]), "\n"); +%} +-- End -- + +-- Expect stdout -- +[ "foo", "bar", "baz" ] +[ "apples", "bananas", "strawberries", "fruits" ] +[ "" ] +[ "" ] +[ "" ] +[ "f", "o", "o", "|", "b", "a", "r", "|", "b", "a", "z" ] +[ "f", "o", "o", "|", "b", "a", "r", "|", "b", "a", "z" ] +[ "foo|bar|baz" ] +[ "foo|bar|baz" ] +[ "abc", "", "", "def" ] +[ "foo", "bar", "", "baz" ] +[ "", "abc", "def", "" ] +[ "", "foo", "bar", "" ] +-- End -- + + +Supplying an invalid input string value will yield `null`. + +-- Testcase -- +{% + printf("%.J\n", split(true, "u")); +%} +-- End -- + +-- Expect stdout -- +null +-- End -- + + +Supplying a non-string, non-regexp separator will yield `null`. + +-- Testcase -- +{% + printf("%.J\n", split("null true false", true)); +%} +-- End -- + +-- Expect stdout -- +null +-- End -- diff --git a/tests/custom/03_stdlib/19_substr b/tests/custom/03_stdlib/19_substr new file mode 100644 index 0000000..0c7eed3 --- /dev/null +++ b/tests/custom/03_stdlib/19_substr @@ -0,0 +1,78 @@ +The `substr()` function extracts a portion of the given input string, +specified by offset and length. and returns the resulting substring. + +If neither an offset, nor a length argument are provided, a copy of +the entire input string is returned. + +If just an offset is specified, the entire remainder of the input string +after the specified offset is returned. + +If both an offset and a length are specified, then that much characters +of the string are extracted, beginning at the offset. + +If either offset or length are negative, they're counted towards the end +of the string. If either value exceeds the input string length, it is +capped to the length. + +Returns the resulting substring. + +Returns `null` if the given input value is not a string. + + +-- Testcase -- +{% + printf("%.J\n", [ + // extract entire string + substr("Hello world!"), + + // extract anything after the 3rd character + substr("Hello world!", 3), + + // extract the last 6 characters + substr("Hello world!", -6), + + // extract chars 5-8 + substr("Hello world!", 4, 3), + + // extract characters 8-10 + substr("Hello world!", -5, -2), + + // overlong values are capped + substr("Hello world!", 100), + substr("Hello world!", 0, 100), + substr("Hello world!", 100, 100), + + // invalid offset or length values are treated as 0 + substr("Hello world!", "inval"), + substr("Hello world!", "inval", "inval") + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "Hello world!", + "lo world!", + "world!", + "o w", + "orl", + "", + "Hello world!", + "", + "Hello world!", + "" +] +-- End -- + + +Supplying an invalid input string value will yield `null`. + +-- Testcase -- +{% + printf("%.J\n", substr(true, 0, 1)); +%} +-- End -- + +-- Expect stdout -- +null +-- End -- diff --git a/tests/custom/03_stdlib/20_time b/tests/custom/03_stdlib/20_time new file mode 100644 index 0000000..173ae09 --- /dev/null +++ b/tests/custom/03_stdlib/20_time @@ -0,0 +1,18 @@ +The `time()` function returns the current UNIX epoch time. + + +-- Testcase -- +{% + let timestamp = time(); + let testcmd = sprintf('t=$(date +%%s); [ $t -gt %d -a $t -lt %d ]', timestamp - 3, timestamp + 3); + + if (system(testcmd) == 0) + print("time() works\n"); + else + print("time() and `date +%s` yield different results!\n"); +%} +-- End -- + +-- Expect stdout -- +time() works +-- End -- diff --git a/tests/custom/03_stdlib/21_uc b/tests/custom/03_stdlib/21_uc new file mode 100644 index 0000000..a5aeed3 --- /dev/null +++ b/tests/custom/03_stdlib/21_uc @@ -0,0 +1,27 @@ +The `uc()` function turns each lower case character in the source string +into upper case and returns the resulting copy. + +The input argument is converted to a string in case it is not already a +string value. + +-- Testcase -- +{% + printf("%.J\n", [ + uc("This Will Be All Uppercased."), + uc([ "An", "array", "ABC" ]), + uc(123), + uc(false), + uc() + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "THIS WILL BE ALL UPPERCASED.", + "[ \"AN\", \"ARRAY\", \"ABC\" ]", + "123", + "FALSE", + "NULL" +] +-- End -- diff --git a/tests/custom/03_stdlib/22_uchr b/tests/custom/03_stdlib/22_uchr new file mode 100644 index 0000000..8f24f3a --- /dev/null +++ b/tests/custom/03_stdlib/22_uchr @@ -0,0 +1,19 @@ +The `uchr()` function takes a series of code point values and turns them +into an UTF-8 encoded string. The resulting string will have as many +characters as there were arguments to the function. The number of bytes +per character varies between 1 to 4, depending on the code point value. + +Invalid numeric arguments or arguments being out of range 0-0x10FFFF will +be encoded as the Unicode replacement character 0xFFFD. + +Returns the resulting UTF-8 string. + +-- Testcase -- +{{ uchr(0x2600, 0x2601, 0x2602) }} +{{ uchr("inval", -1, 0xffffffff) }} +-- End -- + +-- Expect stdout -- +☀☁☂ +��� +-- End -- diff --git a/tests/custom/03_stdlib/23_values b/tests/custom/03_stdlib/23_values new file mode 100644 index 0000000..34b600e --- /dev/null +++ b/tests/custom/03_stdlib/23_values @@ -0,0 +1,35 @@ +The `values()` extracts all values of a given dictionary. The values in the +resulting array are ordered according to the keys which in turn follow +declaration or assignment order. + +Returns an array containg the value of each key within the given dictionary +value. + +Returns `null` if the given dictionary argment is not a valid dictionary. + +-- Testcase -- +{% + printf("%.J\n", [ + values({ foo: true, bar: false, baz: null, qrx: 123, xyz: "test" }), + values({}), + values(true), + values() + ]); +%} +-- End -- + +-- Expect stdout -- +[ + [ + true, + false, + null, + 123, + "test" + ], + [ + ], + null, + null +] +-- End -- diff --git a/tests/custom/03_stdlib/24_trim b/tests/custom/03_stdlib/24_trim new file mode 100644 index 0000000..263fd18 --- /dev/null +++ b/tests/custom/03_stdlib/24_trim @@ -0,0 +1,46 @@ +The `trim()` function removes specific leading and trailing characters from +a given input string. If the characters to trim are unspecified, the space, tab, +carriage return and newline characters will be used by default. + +Returns a copy of the input string with the specified leading and trailing +characters removed. + +Returns `null` if the given input argment is not a valid string value. + +-- Testcase -- +{% + printf("%.J\n", [ + // not specifying trim characters will trim whitespace + trim(" Hello World! \r\n"), + + // if trim characters are specified, only those are removed + trim("|* Foo Bar +|", "+*|"), + + // trim does not affect characters in the middle of the string + trim(" Foo Bar "), + trim("|Foo|Bar|", "|") + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "Hello World!", + " Foo Bar ", + "Foo Bar", + "Foo|Bar" +] +-- End -- + + +Supplying an invalid string will yield `null`. + +-- Testcase -- +{% + printf("%.J\n", trim(true)); +%} +-- End -- + +-- Expect stdout -- +null +-- End -- diff --git a/tests/custom/03_stdlib/25_ltrim b/tests/custom/03_stdlib/25_ltrim new file mode 100644 index 0000000..2001322 --- /dev/null +++ b/tests/custom/03_stdlib/25_ltrim @@ -0,0 +1,46 @@ +The `ltrim()` function removes specific leading characters from the given +input string. If the characters to trim are unspecified, the space, tab, +carriage return and newline characters will be used by default. + +Returns a copy of the input string with the specified leading characters +removed. + +Returns `null` if the given input argment is not a valid string value. + +-- Testcase -- +{% + printf("%.J\n", [ + // not specifying trim characters will trim whitespace + ltrim(" Hello World!"), + + // if trim characters are specified, only those are removed + ltrim("|* Foo Bar +|", "+*|"), + + // ltrim does not affect characters in the middle or the end + ltrim(" Foo Bar "), + ltrim("|Foo|Bar|", "|") + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "Hello World!", + " Foo Bar +|", + "Foo Bar ", + "Foo|Bar|" +] +-- End -- + + +Supplying an invalid string will yield `null`. + +-- Testcase -- +{% + printf("%.J\n", ltrim(true)); +%} +-- End -- + +-- Expect stdout -- +null +-- End -- diff --git a/tests/custom/03_stdlib/26_rtrim b/tests/custom/03_stdlib/26_rtrim new file mode 100644 index 0000000..17b54f7 --- /dev/null +++ b/tests/custom/03_stdlib/26_rtrim @@ -0,0 +1,46 @@ +The `rtrim()` function removes specific trailing characters from the given +input string. If the characters to trim are unspecified, the space, tab, +carriage return and newline characters will be used by default. + +Returns a copy of the input string with the specified trailing characters +removed. + +Returns `null` if the given input argment is not a valid string value. + +-- Testcase -- +{% + printf("%.J\n", [ + // not specifying trim characters will trim whitespace + rtrim("Hello World! \r \n"), + + // if trim characters are specified, only those are removed + rtrim("|* Foo Bar +|", "+*|"), + + // rtrim does not affect characters in the middle or the beginning + rtrim(" Foo Bar "), + rtrim("|Foo|Bar|", "|") + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "Hello World!", + "|* Foo Bar ", + " Foo Bar", + "|Foo|Bar" +] +-- End -- + + +Supplying an invalid string will yield `null`. + +-- Testcase -- +{% + printf("%.J\n", ltrim(true)); +%} +-- End -- + +-- Expect stdout -- +null +-- End -- diff --git a/tests/custom/03_stdlib/27_sprintf b/tests/custom/03_stdlib/27_sprintf new file mode 100644 index 0000000..3edcd48 --- /dev/null +++ b/tests/custom/03_stdlib/27_sprintf @@ -0,0 +1,550 @@ +The `sprintf()` function formats given input value according to a format +string specified as first argument. The format string mimicks the syntax +and directives used by C printf(). + +Each directive (with the exception of %%) in the format string expects +a corresponding argument. If fewer arguments are passed to sprintf() than +required by the format string, missing values will be assumed to be `null` +and be interpreted accordingly. Excess arguments are ignored. + +Returns an output string formatted according to the format string with all +format directives interpolated by their respective values. + +Returns an empty string in case the format string argument is not a valid +string value. + +-- Testcase -- +{% + printf("%.J\n", [ + // String interpolation, corresponding value will be converted + // into string if needed. + sprintf("Hello %s!", "World"), + sprintf("Hello %s!", false), + sprintf("Hello %s!", 123), + sprintf("Hello %s!", null), + sprintf("Hello %s!"), + + // Signed integer interpolation, corresponding value will be + // converted into integer if needed. Also `d` and `i` are aliases. + sprintf("%d", 123), + sprintf("%i", 456.789), + sprintf("%d", true), + sprintf("%d", "0x42"), + sprintf("%d", "invalid"), + sprintf("%d", null), + sprintf("%d", 0xffffffffffffffff), + sprintf("%d"), + + // Unsigned integer interpolation in decimal notation, corresponding + // value will be converted into unsigned integer if needed. + sprintf("%u", 123), + sprintf("%u", -123), + sprintf("%u", 0xffffffffffffffff), + sprintf("%u", 456.789), + sprintf("%u", "invalid"), + sprintf("%u", null), + sprintf("%u"), + + // Unsigned integer interpolation in octal notation, corresponding + // value will be converted into unsigned integer if needed. + sprintf("%o", 123), + sprintf("%o", -123), + sprintf("%o", 0xffffffffffffffff), + sprintf("%o", 456.789), + sprintf("%o", "invalid"), + sprintf("%o", null), + sprintf("%o"), + + // Unsigned integer interpolation in lower case hexadecimal notation, + // corresponding value will be converted into unsigned integer if + // needed. + sprintf("%x", 123), + sprintf("%x", -123), + sprintf("%x", 0xffffffffffffffff), + sprintf("%x", 456.789), + sprintf("%x", "invalid"), + sprintf("%x", null), + sprintf("%x"), + + // Unsigned integer interpolation in upper case hexadecimal notation, + // corresponding value will be converted into unsigned integer if + // needed. + sprintf("%X", 123), + sprintf("%X", -123), + sprintf("%X", 0xffffffffffffffff), + sprintf("%X", 456.789), + sprintf("%X", "invalid"), + sprintf("%X", null), + sprintf("%X"), + + // Floating point value interpolation in exponential notation, + // corresponding value will be converted to double if needed. + sprintf("%e", 123), + sprintf("%e", -123), + sprintf("%e", 456.789), + sprintf("%e", -456.789), + sprintf("%e", "invalid"), + sprintf("%e", null), + sprintf("%e"), + + // Floating point value interpolation in exponential notation, + // using uppercase characters. Corresponding value will be converted + // to double if needed. + sprintf("%E", 123), + sprintf("%E", -123), + sprintf("%E", 456.789), + sprintf("%E", -456.789), + sprintf("%E", "invalid"), + sprintf("%E", null), + sprintf("%E"), + + // Floating point value interpolation in decimal point notation, + // corresponding value will be converted to double if needed. + sprintf("%f", 123), + sprintf("%f", -123), + sprintf("%f", 456.789), + sprintf("%f", -456.789), + sprintf("%f", "invalid"), + sprintf("%f", null), + sprintf("%f"), + + // Floating point value interpolation in decimal point notation, + // using uppercase characters. Corresponding value will be converted + // to double if needed. + sprintf("%F", 123), + sprintf("%F", -123), + sprintf("%F", 456.789), + sprintf("%F", -456.789), + sprintf("%F", "invalid"), + sprintf("%F", null), + sprintf("%F"), + + // Floating point value interpolation in either decimal point or + // exponential notation, depending on size of exponent. Corresponding + // value will be converted to double if needed. + sprintf("%g", 123.456), + sprintf("%g", 0.0000001), + sprintf("%g", "invalid"), + + // Floating point value interpolation in either decimal point or + // exponential notation, depending on size of exponent and using + // uppercase characters. Corresponding value will be converted to + // double if needed. + sprintf("%G", 123.456), + sprintf("%G", 0.0000001), + sprintf("%G", "invalid"), + + // Character interpolation. The corresponding value is casted as `char` + // and the resulting character is interpolated. + sprintf("%c", 65), + sprintf("%c", -1), + sprintf("%c", 456.789), + sprintf("%c", "invalid"), + + // JSON interpolation. The corresponding value is JSON encoded and + // interpolated as string. + sprintf("%J", "Hello\n"), + sprintf("%J", 123), + sprintf("%J", [ 1, 2, 3 ]), + sprintf("%J", { some: "dictionary", an: [ "array", true, false ] }), + sprintf("%J", null), + sprintf("%J"), + + // Escaping `%`. The `%%` format string will produce a literal `%`. + // No corresponding argument is expected. + sprintf("%%") + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "Hello World!", + "Hello false!", + "Hello 123!", + "Hello (null)!", + "Hello (null)!", + "123", + "456", + "1", + "66", + "0", + "0", + "-1", + "0", + "123", + "18446744073709551493", + "18446744073709551615", + "456", + "0", + "0", + "0", + "173", + "1777777777777777777605", + "1777777777777777777777", + "710", + "0", + "0", + "0", + "7b", + "ffffffffffffff85", + "ffffffffffffffff", + "1c8", + "0", + "0", + "0", + "7B", + "FFFFFFFFFFFFFF85", + "FFFFFFFFFFFFFFFF", + "1C8", + "0", + "0", + "0", + "1.230000e+02", + "-1.230000e+02", + "4.567890e+02", + "-4.567890e+02", + "nan", + "0.000000e+00", + "0.000000e+00", + "1.230000E+02", + "-1.230000E+02", + "4.567890E+02", + "-4.567890E+02", + "NAN", + "0.000000E+00", + "0.000000E+00", + "123.000000", + "-123.000000", + "456.789000", + "-456.789000", + "nan", + "0.000000", + "0.000000", + "123.000000", + "-123.000000", + "456.789000", + "-456.789000", + "NAN", + "0.000000", + "0.000000", + "123.456", + "1e-07", + "nan", + "123.456", + "1E-07", + "NAN", + "A", + "\u00ff", + "\u00c8", + "\u0000", + "\"Hello\\n\"", + "123", + "[ 1, 2, 3 ]", + "{ \"some\": \"dictionary\", \"an\": [ \"array\", true, false ] }", + "null", + "null", + "%" +] +-- End -- + + +Field widths may be specified for format directives. + +-- Testcase -- +{% + printf("%.J\n", [ + // by default the output of a format directive is as long as the + // string representation of the corresponding value + sprintf("[%s]", "test"), + + // by specifying a field width, the output will be padded to the + // given length + sprintf("[%10s]", "test"), + + // the same applies to numbers + sprintf("[%10d]", 123), + sprintf("[%10f]", 1.0), + + // and to char formats + sprintf("[%10c]", 65), + + // field width is not applicable to `%` formats + sprintf("[%10%]") + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "[test]", + "[ test]", + "[ 123]", + "[ 1.000000]", + "[ A]", + "[%]" +] +-- End -- + + +Precisions may be specified for format directives. + +-- Testcase -- +{% + print(join("\n", [ + // For `f`, `F`, `e` and `E`, the precision specifies the amount of + // digits after the comma + sprintf("[%.3f]", 1/3), + sprintf("[%.3F]", 1/3), + sprintf("[%.3e]", 1/3), + sprintf("[%.3E]", 1/3), + + // For `g` and `G` the precision specifies the number of significant + // digits to print before switching to exponential notation + sprintf("[%.3g]", 1000.1), + sprintf("[%.3G]", 1000.1), + + // For strings, the precision specifies the amount of characters to + // print at most + sprintf("[%.5s]", "test"), + sprintf("[%.3s]", "test"), + + // For JSON format, the precision specifies the amount of indentation + // to use. Omitting precision will not indent, specifying a precision + // of `0` uses tabs for indentation, any other precision uses this + // many spaces + sprintf("<%J>", [ 1, 2, 3, { true: false } ]), // no indent + sprintf("<%.J>", [ 1, 2, 3, { true: false } ]), // tab indent + sprintf("<%.0J>", [ 1, 2, 3, { true: false } ]), // tab indent + sprintf("<%.1J>", [ 1, 2, 3, { true: false } ]), // indent using one space + sprintf("<%.4J>", [ 1, 2, 3, { true: false } ]), // indent using four spaces + + // precision does not apply to char, integer or `%` formats + sprintf("[%.3d]", 1000), + sprintf("[%.3c]", 65), + sprintf("[%.3%]"), + ]), "\n"); +%} +-- End -- + +-- Expect stdout -- +[0.000] +[0.000] +[0.000e+00] +[0.000E+00] +[1e+03] +[1E+03] +[test] +[tes] +<[ 1, 2, 3, { "true": false } ]> +<[ + 1, + 2, + 3, + { + "true": false + } +]> +<[ + 1, + 2, + 3, + { + "true": false + } +]> +<[ + 1, + 2, + 3, + { + "true": false + } +]> +<[ + 1, + 2, + 3, + { + "true": false + } +]> +[1000] +[A] +[%] +-- End -- + + +A number of flag characters are supported for format directives. + +-- Testcase -- +{% + printf("%.J\n", [ + // The recognized flag characters are `#`, `0`, `-`, `+` and ` ` (space) + sprintf("%#0+- s", "test"), + + // Repetitions of flag characters are accepted + sprintf("%###s", "test"), + sprintf("%000s", "test"), + sprintf("%++-s", "test"), + sprintf("%-- s", "test"), + sprintf("% s", "test"), + + // The `#` flag produces alternative forms of various conversions + sprintf("%o / %#o", 15, 15), + sprintf("%x / %#x", 16, 16), + sprintf("%X / %#X", 17, 17), + sprintf("%g / %#g", 1.0, 1.0), + + // The `0` flag indicates zero- instead of space-padding for various + // numeric conversions. + sprintf("%5d / %05d", -10, -10), + sprintf("%5d / %05d", 11, 11), + sprintf("%5g / %05g", -12.0, -12.0), + sprintf("%5g / %05g", 13.0, 13.0), + sprintf("%5s / %05s", "a", "a"), + + // The `-` flag indicates left, instead of right padding. It will + // override `0` and always pad with spaces + sprintf("%-5d / %-05d", -10, -10), + sprintf("%-5d / %-05d", 11, 11), + sprintf("%-5g / %-05g", -12.0, -12.0), + sprintf("%-5g / %-05g", 13.0, 13.0), + sprintf("%-5s / %-05s", "a", "a"), + + // The `+` flag indicates that a sign (`+` or `-`) should be placed + // before signed numeric values. It overrides ` ` (space). + sprintf("%+5d / %+05d", -10, -10), + sprintf("%+5d / %+05d", 11, 11), + sprintf("%+5g / %+05g", -12.0, -12.0), + sprintf("%+5g / %+05g", 13.0, 13.0), + sprintf("%+5s / %+05s", "a", "a"), + + // The ` ` (space) flag indicates that a blank should be placed + // before positive numbers (useful to ensure that negative and + // positive values in output are aligned) + sprintf("%-5d / %- 5d", -10, -10), + sprintf("%-5d / %- 5d", 11, 11), + sprintf("%-5g / %- 5g", -12.0, -12.0), + sprintf("%-5g / %- 5g", 13.0, 13.0), + sprintf("%-5s / %- 5s", "a", "a"), + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "test", + "test", + "test", + "test", + "test", + "test", + "17 / 017", + "10 / 0x10", + "11 / 0X11", + "1 / 1.00000", + " -10 / -0010", + " 11 / 00011", + " -12 / -0012", + " 13 / 00013", + " a / a", + "-10 / -10 ", + "11 / 11 ", + "-12 / -12 ", + "13 / 13 ", + "a / a ", + " -10 / -0010", + " +11 / +0011", + " -12 / -0012", + " +13 / +0013", + " a / a", + "-10 / -10 ", + "11 / 11 ", + "-12 / -12 ", + "13 / 13 ", + "a / a " +] +-- End -- + + +Unrecognized format directives are copied to the output string as-is. + +-- Testcase -- +{% + printf("%.J\n", [ + // A truncated format directive is preserved + sprintf("test %", "test"), + sprintf("test %-010.3", "test"), + + // An unrecognized format directive is preserved + sprintf("test %y test", 123), + sprintf("test %~123s test", 123) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "test %", + "test %-010.3", + "test %y test", + "test %~123s test" +] +-- End -- + + +Missing values for format directives are treated as `null`. + +-- Testcase -- +{% + printf("%.J\n", [ + sprintf("%s"), + sprintf("%d"), + sprintf("%u"), + sprintf("%o"), + sprintf("%x"), + sprintf("%X"), + sprintf("%f"), + sprintf("%F"), + sprintf("%e"), + sprintf("%E"), + sprintf("%g"), + sprintf("%G"), + sprintf("%c"), + sprintf("%J") + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "(null)", + "0", + "0", + "0", + "0", + "0", + "0.000000", + "0.000000", + "0.000000e+00", + "0.000000E+00", + "0", + "0", + "\u0000", + "null" +] +-- End -- + + +Supplying a non-string format value will yield an empty string result. + +-- Testcase -- +{% + printf("%.J\n", sprintf(true, 1, 2, 3)); +%} +-- End -- + +-- Expect stdout -- +"" +-- End -- diff --git a/tests/custom/03_stdlib/28_printf b/tests/custom/03_stdlib/28_printf new file mode 100644 index 0000000..a2a6d27 --- /dev/null +++ b/tests/custom/03_stdlib/28_printf @@ -0,0 +1,526 @@ +The `printf()` function formats given input value according to a format +string specified as first argument. The format string mimicks the syntax +and directives used by C printf(). + +Each directive (with the exception of %%) in the format string expects +a corresponding argument. If fewer arguments are passed to printf() than +required by the format string, missing values will be assumed to be `null` +and be interpreted accordingly. Excess arguments are ignored. + +Writes the output string formatted according to the format string with all +format directives interpolated by their respective values to the standard +output stream of the VM. + +Returns the number of bytes written to the output stream. + +Writes an empty string in case the format string argument is not a valid +string value. + +-- Testcase -- +{% + // String interpolation, corresponding value will be converted + // into string if needed. + printf("Hello %s!\n", "World"); + printf("Hello %s!\n", false); + printf("Hello %s!\n", 123); + printf("Hello %s!\n", null); + printf("Hello %s!\n"); + + // Signed integer interpolation, corresponding value will be + // converted into integer if needed. Also `d` and `i` are aliases. + printf("%d\n", 123); + printf("%i\n", 456.789); + printf("%d\n", true); + printf("%d\n", "0x42"); + printf("%d\n", "invalid"); + printf("%d\n", null); + printf("%d\n", 0xffffffffffffffff); + printf("%d\n"); + + // Unsigned integer interpolation in decimal notation, corresponding + // value will be converted into unsigned integer if needed. + printf("%u\n", 123); + printf("%u\n", -123); + printf("%u\n", 0xffffffffffffffff); + printf("%u\n", 456.789); + printf("%u\n", "invalid"); + printf("%u\n", null); + printf("%u\n"); + + // Unsigned integer interpolation in octal notation, corresponding + // value will be converted into unsigned integer if needed. + printf("%o\n", 123); + printf("%o\n", -123); + printf("%o\n", 0xffffffffffffffff); + printf("%o\n", 456.789); + printf("%o\n", "invalid"); + printf("%o\n", null); + printf("%o\n"); + + // Unsigned integer interpolation in lower case hexadecimal notation, + // corresponding value will be converted into unsigned integer if + // needed. + printf("%x\n", 123); + printf("%x\n", -123); + printf("%x\n", 0xffffffffffffffff); + printf("%x\n", 456.789); + printf("%x\n", "invalid"); + printf("%x\n", null); + printf("%x\n"); + + // Unsigned integer interpolation in upper case hexadecimal notation, + // corresponding value will be converted into unsigned integer if + // needed. + printf("%X\n", 123); + printf("%X\n", -123); + printf("%X\n", 0xffffffffffffffff); + printf("%X\n", 456.789); + printf("%X\n", "invalid"); + printf("%X\n", null); + printf("%X\n"); + + // Floating point value interpolation in exponential notation, + // corresponding value will be converted to double if needed. + printf("%e\n", 123); + printf("%e\n", -123); + printf("%e\n", 456.789); + printf("%e\n", -456.789); + printf("%e\n", "invalid"); + printf("%e\n", null); + printf("%e\n"); + + // Floating point value interpolation in exponential notation, + // using uppercase characters. Corresponding value will be converted + // to double if needed. + printf("%E\n", 123); + printf("%E\n", -123); + printf("%E\n", 456.789); + printf("%E\n", -456.789); + printf("%E\n", "invalid"); + printf("%E\n", null); + printf("%E\n"); + + // Floating point value interpolation in decimal point notation, + // corresponding value will be converted to double if needed. + printf("%f\n", 123); + printf("%f\n", -123); + printf("%f\n", 456.789); + printf("%f\n", -456.789); + printf("%f\n", "invalid"); + printf("%f\n", null); + printf("%f\n"); + + // Floating point value interpolation in decimal point notation, + // using uppercase characters. Corresponding value will be converted + // to double if needed. + printf("%F\n", 123); + printf("%F\n", -123); + printf("%F\n", 456.789); + printf("%F\n", -456.789); + printf("%F\n", "invalid"); + printf("%F\n", null); + printf("%F\n"); + + // Floating point value interpolation in either decimal point or + // exponential notation, depending on size of exponent. Corresponding + // value will be converted to double if needed. + printf("%g\n", 123.456); + printf("%g\n", 0.0000001); + printf("%g\n", "invalid"); + + // Floating point value interpolation in either decimal point or + // exponential notation, depending on size of exponent and using + // uppercase characters. Corresponding value will be converted to + // double if needed. + printf("%G\n", 123.456); + printf("%G\n", 0.0000001); + printf("%G\n", "invalid"); + + // Character interpolation. The corresponding value is casted as `char` + // and the resulting character is interpolated. + printf("%c\n", 65); + //printf("%c\n", -1); + //printf("%c\n", 456.789); + //printf("%c\n", "invalid"); + + // JSON interpolation. The corresponding value is JSON encoded and + // interpolated as string. + printf("%J\n", "Hello\n"); + printf("%J\n", 123); + printf("%J\n", [ 1, 2, 3 ]); + printf("%J\n", { some: "dictionary", an: [ "array", true, false ] }); + printf("%J\n", null); + printf("%J\n"); + + // Escaping `%`. The `%%` format string will produce a literal `%`. + // No corresponding argument is expected. + printf("%%\n"); +%} +-- End -- + +-- Expect stdout -- +Hello World! +Hello false! +Hello 123! +Hello (null)! +Hello (null)! +123 +456 +1 +66 +0 +0 +-1 +0 +123 +18446744073709551493 +18446744073709551615 +456 +0 +0 +0 +173 +1777777777777777777605 +1777777777777777777777 +710 +0 +0 +0 +7b +ffffffffffffff85 +ffffffffffffffff +1c8 +0 +0 +0 +7B +FFFFFFFFFFFFFF85 +FFFFFFFFFFFFFFFF +1C8 +0 +0 +0 +1.230000e+02 +-1.230000e+02 +4.567890e+02 +-4.567890e+02 +nan +0.000000e+00 +0.000000e+00 +1.230000E+02 +-1.230000E+02 +4.567890E+02 +-4.567890E+02 +NAN +0.000000E+00 +0.000000E+00 +123.000000 +-123.000000 +456.789000 +-456.789000 +nan +0.000000 +0.000000 +123.000000 +-123.000000 +456.789000 +-456.789000 +NAN +0.000000 +0.000000 +123.456 +1e-07 +nan +123.456 +1E-07 +NAN +A +"Hello\n" +123 +[ 1, 2, 3 ] +{ "some": "dictionary", "an": [ "array", true, false ] } +null +null +% +-- End -- + + +Field widths may be specified for format directives. + +-- Testcase -- +{% + // by default the output of a format directive is as long as the + // string representation of the corresponding value + printf("[%s]\n", "test"); + + // by specifying a field width, the output will be padded to the + // given length + printf("[%10s]\n", "test"); + + // the same applies to numbers + printf("[%10d]\n", 123); + printf("[%10f]\n", 1.0); + + // and to char formats + printf("[%10c]\n", 65); + + // field width is not applicable to `%` formats + printf("[%10%]\n"); +%} +-- End -- + +-- Expect stdout -- +[test] +[ test] +[ 123] +[ 1.000000] +[ A] +[%] +-- End -- + + +Precisions may be specified for format directives. + +-- Testcase -- +{% + // For `f`, `F`, `e` and `E`, the precision specifies the amount of + // digits after the comma + printf("[%.3f]\n", 1/3); + printf("[%.3F]\n", 1/3); + printf("[%.3e]\n", 1/3); + printf("[%.3E]\n", 1/3); + + // For `g` and `G` the precision specifies the number of significant + // digits to print before switching to exponential notation + printf("[%.3g]\n", 1000.1); + printf("[%.3G]\n", 1000.1); + + // For strings, the precision specifies the amount of characters to + // print at most + printf("[%.5s]\n", "test"); + printf("[%.3s]\n", "test"); + + // For JSON format, the precision specifies the amount of indentation + // to use. Omitting precision will not indent, specifying a precision + // of `0` uses tabs for indentation, any other precision uses this + // many spaces + printf("<%J>\n", [ 1, 2, 3, { true: false } ]), // no indent + printf("<%.J>\n", [ 1, 2, 3, { true: false } ]), // tab indent + printf("<%.0J>\n", [ 1, 2, 3, { true: false } ]), // tab indent + printf("<%.1J>\n", [ 1, 2, 3, { true: false } ]), // indent using one space + printf("<%.4J>\n", [ 1, 2, 3, { true: false } ]), // indent using four spaces + + // precision does not apply to char, integer or `%` formats + printf("[%.3d]\n", 1000); + printf("[%.3c]\n", 65); + printf("[%.3%]\n"); +%} +-- End -- + +-- Expect stdout -- +[0.000] +[0.000] +[0.000e+00] +[0.000E+00] +[1e+03] +[1E+03] +[test] +[tes] +<[ 1, 2, 3, { "true": false } ]> +<[ + 1, + 2, + 3, + { + "true": false + } +]> +<[ + 1, + 2, + 3, + { + "true": false + } +]> +<[ + 1, + 2, + 3, + { + "true": false + } +]> +<[ + 1, + 2, + 3, + { + "true": false + } +]> +[1000] +[A] +[%] +-- End -- + + +A number of flag characters are supported for format directives. + +-- Testcase -- +{% + // The recognized flag characters are `#`, `0`, `-`, `+` and ` ` (space) + printf("%#0+- s\n", "test"); + + // Repetitions of flag characters are accepted + printf("%###s\n", "test"); + printf("%000s\n", "test"); + printf("%++-s\n", "test"); + printf("%-- s\n", "test"); + printf("% s\n", "test"); + + // The `#` flag produces alternative forms of various conversions + printf("%o / %#o\n", 15, 15); + printf("%x / %#x\n", 16, 16); + printf("%X / %#X\n", 17, 17); + printf("%g / %#g\n", 1.0, 1.0); + + // The `0` flag indicates zero- instead of space-padding for various + // numeric conversions. + printf("[%5d / %05d]\n", -10, -10); + printf("[%5d / %05d]\n", 11, 11); + printf("[%5g / %05g]\n", -12.0, -12.0); + printf("[%5g / %05g]\n", 13.0, 13.0); + printf("[%5s / %05s]\n", "a", "a"); + + // The `-` flag indicates left, instead of right padding. It will + // override `0` and always pad with spaces + printf("[%-5d / %-05d]\n", -10, -10); + printf("[%-5d / %-05d]\n", 11, 11); + printf("[%-5g / %-05g]\n", -12.0, -12.0); + printf("[%-5g / %-05g]\n", 13.0, 13.0); + printf("[%-5s / %-05s]\n", "a", "a"); + + // The `+` flag indicates that a sign (`+` or `-`) should be placed + // before signed numeric values. It overrides ` ` (space). + printf("[%+5d / %+05d]\n", -10, -10); + printf("[%+5d / %+05d]\n", 11, 11); + printf("[%+5g / %+05g]\n", -12.0, -12.0); + printf("[%+5g / %+05g]\n", 13.0, 13.0); + printf("[%+5s / %+05s]\n", "a", "a"); + + // The ` ` (space) flag indicates that a blank should be placed + // before positive numbers (useful to ensure that negative and + // positive values in output are aligned) + printf("[%-5d / %- 5d]\n", -10, -10); + printf("[%-5d / %- 5d]\n", 11, 11); + printf("[%-5g / %- 5g]\n", -12.0, -12.0); + printf("[%-5g / %- 5g]\n", 13.0, 13.0); + printf("[%-5s / %- 5s]\n", "a", "a"); +%} +-- End -- + +-- Expect stdout -- +test +test +test +test +test +test +17 / 017 +10 / 0x10 +11 / 0X11 +1 / 1.00000 +[ -10 / -0010] +[ 11 / 00011] +[ -12 / -0012] +[ 13 / 00013] +[ a / a] +[-10 / -10 ] +[11 / 11 ] +[-12 / -12 ] +[13 / 13 ] +[a / a ] +[ -10 / -0010] +[ +11 / +0011] +[ -12 / -0012] +[ +13 / +0013] +[ a / a] +[-10 / -10 ] +[11 / 11 ] +[-12 / -12 ] +[13 / 13 ] +[a / a ] +-- End -- + + +Unrecognized format directives are copied to the output string as-is. + +-- Testcase -- +{% + // A truncated format directive is preserved + printf("test %\n", "test"); + printf("test %-010.3\n", "test"); + + // An unrecognized format directive is preserved + printf("test %y test\n", 123); + printf("test %~123s test\n", 123); +%} +-- End -- + +-- Expect stdout -- +test % +test %-010.3 +test %y test +test %~123s test +-- End -- + + +Missing values for format directives are treated as `null`. + +-- Testcase -- +{% + printf("%s\n"); + printf("%d\n"); + printf("%u\n"); + printf("%o\n"); + printf("%x\n"); + printf("%X\n"); + printf("%f\n"); + printf("%F\n"); + printf("%e\n"); + printf("%E\n"); + printf("%g\n"); + printf("%G\n"); + //printf("%c\n"); + printf("%J\n"); +%} +-- End -- + +-- Expect stdout -- +(null) +0 +0 +0 +0 +0 +0.000000 +0.000000 +0.000000e+00 +0.000000E+00 +0 +0 +null +-- End -- + + +Supplying a non-string format value will yield an empty string result. + +-- Testcase -- +{% + printf(true, 1, 2, 3); +%} +-- End -- + +-- Expect stdout -- +-- End -- diff --git a/tests/custom/03_stdlib/29_require b/tests/custom/03_stdlib/29_require new file mode 100644 index 0000000..681f3f7 --- /dev/null +++ b/tests/custom/03_stdlib/29_require @@ -0,0 +1,164 @@ +The `require()` function loads the specified module, executes it and returns +the returned value to the caller. + +The global array `REQUIRE_SEARCH_PATH` specifies the list of locations to +check for a matching module file. + +The return value of a successfully loaded module is cached in a global +registry, subsequent require calls with the same name will return the +cached value. + +Throws an exception if the global `REQUIRE_SEARCH_PATH` variable is unset or +not pointing to an array. + +Throws an exception if the requested module name cannot be found. + +Throws an exception if a module file could be found but not opened. + +Throws an exception if a module file could not be compiled. + +Returns the value returned by the invoked module code (typically an object). + +-- Testcase -- +{% + push(REQUIRE_SEARCH_PATH, TESTFILES_PATH + '/*.uc'); + + let mod1 = require("require.test.module"); + printf("require() #1 returned %.J\n\n", mod1); + + let mod2 = require("require.test.module"); + printf("require() #2 returned %.J\n\n", mod2); + + printf("Instances are identical: %s\n\n", mod1 === mod2); + + // deleting the entry from the global module registry forces reload + delete global.modules["require.test.module"]; + + let mod3 = require("require.test.module"); + printf("require() #3 returned %.J\n\n", mod3); + + printf("Instances are identical: %s\n\n", mod1 === mod3); +%} +-- End -- + +-- File require/test/module.uc -- +{% + print("This is require.test.module running!\n\n"); + + return { + greeting: function(name) { + printf("Hello, %s!\n", name); + } + }; +%} +-- End -- + +-- Expect stdout -- +This is require.test.module running! + +require() #1 returned { + "greeting": "function(name) { ... }" +} + +require() #2 returned { + "greeting": "function(name) { ... }" +} + +Instances are identical: true + +This is require.test.module running! + +require() #3 returned { + "greeting": "function(name) { ... }" +} + +Instances are identical: false + +-- End -- + + +A clobbered `REQUIRE_SEARCH_PATH` triggers an exception. + +-- Testcase -- +{% + REQUIRE_SEARCH_PATH = null; + + require("test"); +%} +-- End -- + +-- Expect stderr -- +Runtime error: Global require search path not set +In line 4, byte 16: + + ` require("test");` + Near here --------^ + + +-- End -- + + +A not found module triggers an exception. + +-- Testcase -- +{% + require("test"); +%} +-- End -- + +-- Expect stderr -- +Runtime error: No module named 'test' could be found +In line 2, byte 16: + + ` require("test");` + Near here --------^ + + +-- End -- + + +A compilation error in the module triggers an exception. + +-- Testcase -- +{% + try { + push(REQUIRE_SEARCH_PATH, TESTFILES_PATH + '/*.uc'); + + require("require.test.broken"); + } + catch (e) { + // Catch and rethrow exception with modified message to + // ensure stable test output. + e.message = replace(e.message, + /(compile module '.+require\/test\/broken\.uc')/, + "compile module '.../require/test/broken.uc'"); + + die(e); + } +%} +-- End -- + +-- File require/test/broken.uc -- +{% + // Unclosed object to force syntax error + return { +%} +-- End -- + +-- Expect stderr -- +Unable to compile module '.../require/test/broken.uc': +Syntax error: Expecting label +In line 3, byte 11: + + ` return {` + Near here --^ + + + +In line 14, byte 8: + + ` die(e);` + Near here ---^ + + +-- End -- diff --git a/tests/custom/03_stdlib/30_iptoarr b/tests/custom/03_stdlib/30_iptoarr new file mode 100644 index 0000000..5f1ae24 --- /dev/null +++ b/tests/custom/03_stdlib/30_iptoarr @@ -0,0 +1,46 @@ +The `iptoarr()` function parses the given IP address string into an array +of byte values. + +Returns an array of byte values for the parsed IP address. + +Returns `null` if the given IP argument is not a string value or if the +IP address could not be parsed. + +-- Testcase -- +{% + print(join("\n", [ + iptoarr("0.0.0.0"), + iptoarr("10.11.12.13"), + iptoarr("::"), + iptoarr("::ffff:192.168.1.1"), + iptoarr("2001:db8:1234:4567:789a:bcde:f012:3456"), + iptoarr("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff") + ]), "\n"); +%} +-- End -- + +-- Expect stdout -- +[ 0, 0, 0, 0 ] +[ 10, 11, 12, 13 ] +[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ] +[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 192, 168, 1, 1 ] +[ 32, 1, 13, 184, 18, 52, 69, 103, 120, 154, 188, 222, 240, 18, 52, 86 ] +[ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 ] +-- End -- + + +Supplying a non-string value or an unparsable address yields `null`. + +-- Testcase -- +{% + print(join("\n", [ + iptoarr(true), + iptoarr("invalid") + ]), "\n"); +%} +-- End -- + +-- Expect stdout -- +null +null +-- End -- diff --git a/tests/custom/03_stdlib/31_arrtoip b/tests/custom/03_stdlib/31_arrtoip new file mode 100644 index 0000000..61d82e1 --- /dev/null +++ b/tests/custom/03_stdlib/31_arrtoip @@ -0,0 +1,57 @@ +The `arrtoip()` function converts the given byte array into an IP address +string. Array of length 4 are converted to IPv4 addresses, arrays of +length 16 to IPv6 addresses. + +Returns the resulting IPv4 or IPv6 address string. + +Returns `null` if the given value is not an array, if the array has an +unsuitable length or if any item within the array is not an integer within +the range 0-255. + +-- Testcase -- +{% + print(join("\n", [ + arrtoip([ 0, 0, 0, 0 ]), + arrtoip([ 192, 168, 1, 1 ]), + arrtoip([ 255, 255, 255, 255 ]), + arrtoip([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]), + arrtoip([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 192, 168, 1, 1 ]), + arrtoip([ 32, 1, 13, 184, 18, 52, 69, 103, 120, 154, 188, 222, 240, 18, 52, 86 ]), + arrtoip([ 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255 ]) + ]), "\n"); +%} +-- End -- + +-- Expect stdout -- +0.0.0.0 +192.168.1.1 +255.255.255.255 +:: +::ffff:192.168.1.1 +2001:db8:1234:4567:789a:bcde:f012:3456 +ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff +-- End -- + + +Supplying a non-array value, an array of unsuitable length or an array +containing invalid byte values yields `null`. + +-- Testcase -- +{% + print(join("\n", [ + arrtoip(true), + arrtoip([ ]), + arrtoip([ 1, 2, 3 ]), + arrtoip([ 192, 168, 1, -1 ]), + arrtoip([ true, false, -5, 500 ]) + ]), "\n"); +%} +-- End -- + +-- Expect stdout -- +null +null +null +null +null +-- End -- diff --git a/tests/custom/03_stdlib/32_match b/tests/custom/03_stdlib/32_match new file mode 100644 index 0000000..b053044 --- /dev/null +++ b/tests/custom/03_stdlib/32_match @@ -0,0 +1,55 @@ +The `match()` function applies the given regular expression pattern on +the given subject value. + +Depending on whether the given regular expression sets the global (`g`) +modifier, either an array of match groups or the first match group is +returned. + +Returns `null` if the given pattern argument is not a regular expression +value, or if the subject is `null` or unspecified. + +-- Testcase -- +{% + print(join("\n", [ + // match all key=value pairs + match("kind=fruit name=strawberry color=red", /([[:alpha:]]+)=([^= ]+)/g), + + // match any word + match("The quick brown fox jumps over the lazy dog", /[[:alpha:]]+/g), + + // match the first three lowercase words + match("The quick brown fox jumps over the lazy dog", / ([[:lower:]]+) ([[:lower:]]+) ([[:lower:]]+)/), + + // special case: match any empty string sequence + match("foo", /()/g), + + // special case: match first empty string sequence + match("foo", /()/), + + // subject is implictly converted to string + match(true, /u/) + ]), "\n"); +%} +-- End -- + +-- Expect stdout -- +[ [ "kind=fruit", "kind", "fruit" ], [ "name=strawberry", "name", "strawberry" ], [ "color=red", "color", "red" ] ] +[ [ "The" ], [ "quick" ], [ "brown" ], [ "fox" ], [ "jumps" ], [ "over" ], [ "the" ], [ "lazy" ], [ "dog" ] ] +[ " quick brown fox", "quick", "brown", "fox" ] +[ [ "", "" ], [ "", "" ], [ "", "" ], [ "", "" ] ] +[ "", "" ] +[ "u" ] +-- End -- + + +Omitting the subject yields `null`. + +-- Testcase -- +{% + printf("%.J\n", match(null, /u/)); +%} +-- End -- + +-- Expect stdout -- +null +-- End -- diff --git a/tests/custom/03_stdlib/33_replace b/tests/custom/03_stdlib/33_replace new file mode 100644 index 0000000..b662ae8 --- /dev/null +++ b/tests/custom/03_stdlib/33_replace @@ -0,0 +1,207 @@ +The `replace()` function replaces the given regular expression or plain +string pattern on the given subject value with the specified replacement. + +In case a regular expression with the global (`g`) modifier set or a +string is passed as pattern, all found occurrences are replaced. In case +a regular expression without global modifier is given, only the first +match will be replaced. + +The replacement value may be either a string, which is inserted in place +of the matched result after certain interpolation steps or a function +which is invoked for each match and whose return value is used as +replacement. + +The subject is implicitly converted to a string if it is not a string. + +The pattern is implicitly converted to a string if it is neither a string +nor a regular expression value. + +The replacement value is implicitly converted to a string if it is neither +a string nor a function value. + +Returns a copy of the input string with the match(es) replaced by their +corresponding replacement values. + +Returns `null` either the subject, the pattern or the replacement value +is `null`. + +-- Testcase -- +{% + print(join("\n###\n", [ + // Capitalize and reformat all key=value pairs using a callback + replace("kind=fruit name=strawberry color=red", + /([[:alpha:]])([[:alpha:]]*)=(.)([^= ]*) */g, + function(m, letter1, rest1, letter2, rest2) { + return sprintf('%s%s: %s%s\n', + uc(letter1), rest1, + uc(letter2), rest2 + ); + }), + + // strike any three letter word + replace("The quick brown fox jumps over the lazy dog", + /(^| )([[:alpha:]]{3})( |$)/g, + "$1<s>$2</s>$3"), + + // highlight any vowel + replace("The quick brown fox jumps over the lazy dog", + /[aeiou]/g, + "[$&]"), + + // replace with fixed pattern + replace("foo bar foo baz foo qrx", "foo", "xxx"), + + // testing all possible replacement interpolations + replace("before abc def ghi jkl mno pqr stu vwx yz! after", + / ([a-z]{3}) ([a-z]{3}) ([a-z]{3}) ([a-z]{3}) ([a-z]{3}) ([a-z]{3}) ([a-z]{3}) ([a-z]{3}) ([a-z!]{3}) /, + '|\n---\n' + + 'Entire match ($$&): [$&]\n' + + 'Before match ($$`): [$`]\n' + + "After match ($$'): [$']\n" + + 'Group 1 match ($$1): [$1]\n' + + 'Group 2 match ($$2): [$2]\n' + + 'Group 3 match ($$3): [$3]\n' + + 'Group 4 match ($$4): [$4]\n' + + 'Group 5 match ($$5): [$5]\n' + + 'Group 6 match ($$6): [$6]\n' + + 'Group 7 match ($$7): [$7]\n' + + 'Group 8 match ($$8): [$8]\n' + + 'Group 9 match ($$9): [$9]\n' + + 'Literal $$: [$$]\n' + + '---\n|'), + + // testing that all captures are passed to the callback + replace("before abc def ghi jkl mno pqr stu vwx yz! after", + / ([a-z]{3}) ([a-z]{3}) ([a-z]{3}) ([a-z]{3}) ([a-z]{3}) ([a-z]{3}) ([a-z]{3}) ([a-z]{3}) ([a-z!]{3}) /, + function(m0, m1, m2, m3, m4, m5, m6, m7, m8, m9) { + return sprintf( + '|\n---\n' + + 'Entire match (arg 0): [%s]\n' + + 'Group 1 match (arg 1): [%s]\n' + + 'Group 2 match (arg 2): [%s]\n' + + 'Group 3 match (arg 3): [%s]\n' + + 'Group 4 match (arg 4): [%s]\n' + + 'Group 5 match (arg 5): [%s]\n' + + 'Group 6 match (arg 6): [%s]\n' + + 'Group 7 match (arg 7): [%s]\n' + + 'Group 8 match (arg 8): [%s]\n' + + 'Group 9 match (arg 9): [%s]\n' + + '---\n|', + m0, m1, m2, m3, m4, m5, m6, m7, m8, m9 + ); + }), + + // the subject is implictly stringified + replace({ foo: true }, "foo", "xxx"), + + // the pattern is implictly stringified + replace({ foo: true }, true, "false"), + + // the replacement is implictly stringified + replace({ foo: true }, "foo", 0x7b), + + // special case: replace all empty matches + replace("foo", "", "."), + replace("foo", /()/g, ".") + ]), "\n"); +%} +-- End -- + +-- Expect stdout -- +Kind: Fruit +Name: Strawberry +Color: Red + +### +<s>The</s> quick brown <s>fox</s> jumps over <s>the</s> lazy <s>dog</s> +### +Th[e] q[u][i]ck br[o]wn f[o]x j[u]mps [o]v[e]r th[e] l[a]zy d[o]g +### +xxx bar xxx baz xxx qrx +### +before | +--- +Entire match ($&): [ abc def ghi jkl mno pqr stu vwx yz! ] +Before match ($`): [before ] +After match ($'): [ after] +Group 1 match ($1): [abc] +Group 2 match ($2): [def] +Group 3 match ($3): [ghi] +Group 4 match ($4): [jkl] +Group 5 match ($5): [mno] +Group 6 match ($6): [pqr] +Group 7 match ($7): [stu] +Group 8 match ($8): [vwx] +Group 9 match ($9): [yz!] +Literal $: [$] +--- +| after +### +before | +--- +Entire match (arg 0): [ abc def ghi jkl mno pqr stu vwx yz! ] +Group 1 match (arg 1): [abc] +Group 2 match (arg 2): [def] +Group 3 match (arg 3): [ghi] +Group 4 match (arg 4): [jkl] +Group 5 match (arg 5): [mno] +Group 6 match (arg 6): [pqr] +Group 7 match (arg 7): [stu] +Group 8 match (arg 8): [vwx] +Group 9 match (arg 9): [yz!] +--- +| after +### +{ "xxx": true } +### +{ "foo": false } +### +{ "123": true } +### +.f.o.o. +### +.f.o.o. +-- End -- + + +Omitting subject, pattern or replacement yields `null`. + +-- Testcase -- +{% + printf("%.J\n", [ + replace(null, "u", "x"), + replace("nullnull", null, "x"), + replace("foo", "o", null) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + null, + null, + null +] +-- End -- + + +Exceptions in the callback terminate the replacement process and are +propagated to the calling context. + +-- Testcase -- +{% + replace("foo", "o", function(m) { die() }); +%} +-- End -- + +-- Expect stderr -- +Died +In [anonymous function](), line 2, byte 40: + called from function replace ([C]) + called from anonymous function ([stdin]:2:43) + + ` replace("foo", "o", function(m) { die() });` + Near here --------------------------------^ + + +-- End -- diff --git a/tests/custom/03_stdlib/34_json b/tests/custom/03_stdlib/34_json new file mode 100644 index 0000000..ba8ad9f --- /dev/null +++ b/tests/custom/03_stdlib/34_json @@ -0,0 +1,110 @@ +The `json()` function parses the given string value as JSON. + +Throws an exception if the given input value is not a string. +Throws an exception if the given input string cannot be parsed as JSON. + +Returns the resulting value. + +-- Testcase -- +{% + print(join("\n", [ + json("null"), + json("true"), + json("false"), + json("123"), + json("456.7890000"), + json("-1.4E10"), + json("1e309"), + json('"A string \u2600"'), + json("[ 1, 2, 3 ]"), + json('{ "test": [ 1, 2, 3 ] }'), + + // surrounding white space is ignored + json(' [ 1, 2, 3 ] ') + ]), "\n"); +%} +-- End -- + +-- Expect stdout -- +null +true +false +123 +456.789 +-1.4e+10 +Infinity +A string ☀ +[ 1, 2, 3 ] +{ "test": [ 1, 2, 3 ] } +[ 1, 2, 3 ] +-- End -- + + +Passing a non-string value throws an exception. + +-- Testcase -- +{% + json(true); +%} +-- End -- + +-- Expect stderr -- +Type error: Passed value is not a string +In line 2, byte 11: + + ` json(true);` + Near here ---^ + + +-- End -- + + +Unparseable JSON throws exceptions. + +-- Testcase -- +{% + json('[ "incomplete", "array" '); +%} +-- End -- + +-- Expect stderr -- +Syntax error: Failed to parse JSON string: unexpected end of data +In line 2, byte 33: + + ` json('[ "incomplete", "array" ');` + Near here -------------------------^ + + +-- End -- + +-- Testcase -- +{% + json('invalid syntax'); +%} +-- End -- + +-- Expect stderr -- +Syntax error: Failed to parse JSON string: unexpected character +In line 2, byte 23: + + ` json('invalid syntax');` + Near here ---------------^ + + +-- End -- + +-- Testcase -- +{% + json('[] trailing garbage'); +%} +-- End -- + +-- Expect stderr -- +Syntax error: Trailing garbage after JSON data +In line 2, byte 28: + + ` json('[] trailing garbage');` + Near here --------------------^ + + +-- End -- diff --git a/tests/custom/03_stdlib/35_include b/tests/custom/03_stdlib/35_include new file mode 100644 index 0000000..6d808f2 --- /dev/null +++ b/tests/custom/03_stdlib/35_include @@ -0,0 +1,173 @@ +The `include()` function executes the specified path as ucode script, +optionally setting a different execution scope for the invoked file. + +If the specified path is relative, it is treated as being relative to the +source file currently being executed or the current working directory in +case the interpreter executes code from stdin or a command line argument. + +Throws an exception if the given path value is not a string. + +Throws an exception if a scope argument is specified and not a valid object. + +Throws an exception if the given path could not be found or opened. + +Throws an exception if the given file could not be compiled. + +Returns no value. + +-- Testcase -- +{% + let real_printf = printf; + + // include by relative path + include("files/include.uc"); + + printf("---\n"); + + // include by absolute path + include(TESTFILES_PATH + "/include.uc"); + + printf("---\n"); + + // include with overridden scope + include("files/include.uc", { + printf: function(...args) { + real_printf("This is the wrapped printf() getting called!\n"); + + return real_printf(...args); + } + }); + + printf("---\n"); + + // include with isolated scope + include("files/include.uc", proto({ + printf: function(...args) { + real_printf("This is the wrapped printf() getting called!\n"); + + return real_printf(...args); + } + }, {})); +%} +-- End -- + +-- File include.uc -- +{% + printf("This is the include file running! Can I access the global env? %s\n", + REQUIRE_SEARCH_PATH ? "Yes!" : "No."); +%} +-- End -- + +-- Expect stdout -- +This is the include file running! Can I access the global env? Yes! +--- +This is the include file running! Can I access the global env? Yes! +--- +This is the wrapped printf() getting called! +This is the include file running! Can I access the global env? Yes! +--- +This is the wrapped printf() getting called! +This is the include file running! Can I access the global env? No. +-- End -- + + +An invalid path value triggers an exception. + +-- Testcase -- +{% + include(true); +%} +-- End -- + +-- Expect stderr -- +Type error: Passed filename is not a string +In line 2, byte 14: + + ` include(true);` + Near here ------^ + + +-- End -- + + +An invalid scope value triggers an exception. + +-- Testcase -- +{% + include("test", true); +%} +-- End -- + +-- Expect stderr -- +Type error: Passed scope value is not an object +In line 2, byte 22: + + ` include("test", true);` + Near here --------------^ + + +-- End -- + + +A not found file triggers an exception. + +-- Testcase -- +{% + include("files/doesnotexist.uc"); +%} +-- End -- + +-- Expect stderr -- +Runtime error: Include file not found +In line 2, byte 33: + + ` include("files/doesnotexist.uc");` + Near here -------------------------^ + + +-- End -- + + +A compilation error in the file triggers an exception. + +-- Testcase -- +{% + try { + include("files/broken.uc"); + } + catch (e) { + // Catch and rethrow exception with modified message to + // ensure stable test output. + e.message = replace(e.message, + /(compile module '.+broken\.uc')/, + "compile module '.../broken.uc'"); + + die(e); + } +%} +-- End -- + +-- File broken.uc -- +{% + // Unclosed object to force syntax error + return { +%} +-- End -- + +-- Expect stderr -- +Unable to compile module '.../broken.uc': +Syntax error: Expecting label +In line 3, byte 11: + + ` return {` + Near here --^ + + + +In line 12, byte 8: + + ` die(e);` + Near here ---^ + + +-- End -- diff --git a/tests/custom/03_stdlib/36_render b/tests/custom/03_stdlib/36_render new file mode 100644 index 0000000..64ef08a --- /dev/null +++ b/tests/custom/03_stdlib/36_render @@ -0,0 +1,167 @@ +The `render()` function executes the specified path as ucode script, +optionally setting a different execution scope for the invoked file, +and captures the produced output in a string. + +If the specified path is relative, it is treated as being relative to the +source file currently being executed or the current working directory in +case the interpreter executes code from stdin or a command line argument. + +Throws an exception if the given path value is not a string. + +Throws an exception if a scope argument is specified and not a valid object. + +Throws an exception if the given path could not be found or opened. + +Throws an exception if the given file could not be compiled. + +Returns a string containing the captured output of the executed file. + +-- Testcase -- +{% + let real_printf = printf; + + printf("%.J\n", [ + // include by relative path + render("files/include.uc"), + + // include by absolute path + render(TESTFILES_PATH + "/include.uc"), + + // include with overridden scope + render("files/include.uc", { + printf: function(...args) { + real_printf("This is the wrapped printf() getting called!\n"); + + return real_printf(...args); + } + }), + + // include with isolated scope + render("files/include.uc", proto({ + printf: function(...args) { + real_printf("This is the wrapped printf() getting called!\n"); + + return real_printf(...args); + } + }, {})) + ]); +%} +-- End -- + +-- File include.uc -- +{% + printf("This is the include file running! Can I access the global env? %s\n", + REQUIRE_SEARCH_PATH ? "Yes!" : "No."); +%} +-- End -- + +-- Expect stdout -- +[ + "This is the include file running! Can I access the global env? Yes!\n", + "This is the include file running! Can I access the global env? Yes!\n", + "This is the wrapped printf() getting called!\nThis is the include file running! Can I access the global env? Yes!\n", + "This is the wrapped printf() getting called!\nThis is the include file running! Can I access the global env? No.\n" +] +-- End -- + + +An invalid path value triggers an exception. + +-- Testcase -- +{% + include(true); +%} +-- End -- + +-- Expect stderr -- +Type error: Passed filename is not a string +In line 2, byte 14: + + ` include(true);` + Near here ------^ + + +-- End -- + + +An invalid scope value triggers an exception. + +-- Testcase -- +{% + include("test", true); +%} +-- End -- + +-- Expect stderr -- +Type error: Passed scope value is not an object +In line 2, byte 22: + + ` include("test", true);` + Near here --------------^ + + +-- End -- + + +A not found file triggers an exception. + +-- Testcase -- +{% + include("files/doesnotexist.uc"); +%} +-- End -- + +-- Expect stderr -- +Runtime error: Include file not found +In line 2, byte 33: + + ` include("files/doesnotexist.uc");` + Near here -------------------------^ + + +-- End -- + + +A compilation error in the file triggers an exception. + +-- Testcase -- +{% + try { + include("files/broken.uc"); + } + catch (e) { + // Catch and rethrow exception with modified message to + // ensure stable test output. + e.message = replace(e.message, + /(compile module '.+broken\.uc')/, + "compile module '.../broken.uc'"); + + die(e); + } +%} +-- End -- + +-- File broken.uc -- +{% + // Unclosed object to force syntax error + return { +%} +-- End -- + +-- Expect stderr -- +Unable to compile module '.../broken.uc': +Syntax error: Expecting label +In line 3, byte 11: + + ` return {` + Near here --^ + + + +In line 12, byte 8: + + ` die(e);` + Near here ---^ + + +-- End -- diff --git a/tests/custom/03_stdlib/37_warn b/tests/custom/03_stdlib/37_warn new file mode 100644 index 0000000..2c0ff24 --- /dev/null +++ b/tests/custom/03_stdlib/37_warn @@ -0,0 +1,40 @@ +The `warn()` function outputs the given values to stderr. + +Returns the amount of bytes written. + +-- Testcase -- +{% + let n = 0; + + n += warn(null, "\n"); + n += warn(true, "\n"); + n += warn(false, "\n"); + n += warn(123, "\n"); + n += warn(456.789, "\n"); + n += warn(NaN, "\n"); + n += warn(Infinity, "\n"); + n += warn("Hello world", "\n"); + n += warn([ 1, 2, 3 ], "\n"); + n += warn({ some: "dict" }, "\n"); + n += warn(warn, "\n"); + + warn(n, " bytes written\n"); +%} +-- End -- + +-- Expect stderr -- + +true +false +123 +456.789 +NaN +Infinity +Hello world +[ 1, 2, 3 ] +{ "some": "dict" } +function warn(...) { [native code] } +117 bytes written +-- End -- + + diff --git a/tests/custom/03_stdlib/38_system b/tests/custom/03_stdlib/38_system new file mode 100644 index 0000000..faf8aa5 --- /dev/null +++ b/tests/custom/03_stdlib/38_system @@ -0,0 +1,148 @@ +The `system()` function executes the given shell command or raw command +vector, optionally terminating the spawned process after the specified +timeout. + +Throws an exception if a timeout is specified but not a valid positive +integer value. + +Throws an exception if the command argument is neither an array nor a +string value. + +Throws an exception if an empty command vector is given. + +Returns the exit code of the invoked process. + +-- Testcase -- +{% + // When passing the command as string, `/bin/sh -c` is invoked with + // the given command string as second argument + system('x=1; echo $((x + x))'); + + // When passing the command as array, the first value is taken as + // executable to invoke and any further item as argument to the + // invoked program. Internally `execvp()` is used, which means that + // the executable path may be relative in which case it is looked + // up in the directories specified by `$PATH`. Any array items are + // implicitly stringified. + system([ '/bin/sh', TESTFILES_PATH + '/testscripts/hello.sh', true, 0x42, 123.456000, { some: "dict" } ]); + + // By specifying a timeout, maximum execution time is limited to + // that many milliseconds. If the program does not finish before the + // timeout occurs, it is forcibly terminated with SIGKILL. + system([ '/bin/sh', TESTFILES_PATH + '/testscripts/sleep.sh' ], 100); + + // The return value of system() is the exit code of the invoked program. + let rc = system([ '/bin/sh', TESTFILES_PATH + '/testscripts/exit.sh' ]); + + printf("Return value is %d\n", rc); +%} +-- End -- + +-- File testscripts/hello.sh -- +#!/bin/sh + +echo "This is our test program running!" +echo "My arguments are:" + +for arg in "$@"; do + echo "<$arg>" +done +-- End -- + +-- File testscripts/sleep.sh -- +#!/bin/sh + +echo "I'll sleep for 10s now..." +sleep 10 +echo "I am done sleeping." +-- End -- + +-- File testscripts/exit.sh -- +#!/bin/sh + +echo "I'll exit with code 5 now." +exit 5 +-- End -- + +-- Expect stdout -- +2 +This is our test program running! +My arguments are: +<true> +<66> +<123.456> +<{ "some": "dict" }> +I'll sleep for 10s now... +I'll exit with code 5 now. +Return value is 5 +-- End -- + + +Passing an invalid command value throws an exception. + +-- Testcase -- +{% + system(true); +%} +-- End -- + +-- Expect stderr -- +Type error: Passed command is neither string nor array +In line 2, byte 13: + + ` system(true);` + Near here -----^ + + +-- End -- + +-- Testcase -- +{% + system([]); +%} +-- End -- + +-- Expect stderr -- +Type error: Passed command array is empty +In line 2, byte 11: + + ` system([]);` + Near here ---^ + + +-- End -- + + +Passing an invalid timeout throws an exception. + +-- Testcase -- +{% + system("exit 0", "invalid") +%} +-- End -- + +-- Expect stderr -- +Type error: Invalid timeout specified +In line 2, byte 28: + + ` system("exit 0", "invalid")` + Near here --------------------^ + + +-- End -- + +-- Testcase -- +{% + system("exit 0", -100) +%} +-- End -- + +-- Expect stderr -- +Type error: Invalid timeout specified +In line 2, byte 23: + + ` system("exit 0", -100)` + Near here ---------------^ + + +-- End -- diff --git a/tests/custom/03_stdlib/39_trace b/tests/custom/03_stdlib/39_trace new file mode 100644 index 0000000..2b2295a --- /dev/null +++ b/tests/custom/03_stdlib/39_trace @@ -0,0 +1,79 @@ +The `trace()` function sets the execution trace level of the VM. + +Throws an exception if trace level argument is not a valid integer. + +Returns the previously used execution trace level. + +-- Testcase -- +{% + printf("Code before enabling tracing.\n"); + + trace(1); + + printf("Code after enabling tracing.\n"); + + trace(0); + + printf("Code after disabling tracing.\n"); +%} +-- End -- + +-- Expect stdout -- +Code before enabling tracing. +Code after enabling tracing. +Code after disabling tracing. +-- End -- + +-- Expect stderr -- + [-2] 1 + [-1] "function trace(...) { [native code] }" + [+1] 0 +[2;40;97m [stdin]:4 trace(1[22m);[m +0000001c POP + [-1] 0 +0000001d LVAR {0x0} ; "printf" + [+1] "function printf(...) { [native code] }" +[2;40;97m [stdin]:6 [22mprintf("Code after enabling tracing.\n");[m +00000022 LOAD {0x3} ; "Code after enabling tracing.\n" + [+2] "Code after enabling tracing.\n" +[2;40;97m [stdin]:6 printf([22m"Code after enabling tracing.\n");[m +00000027 CALL {0x1} + [*] CALLFRAME[1] + |- stackframe 1/3 + |- ctx null + [-2] "Code after enabling tracing.\n" + [-1] "function printf(...) { [native code] }" + [+1] 29 +[2;40;97m [stdin]:6 printf("Code after enabling tracing.\n"[22m);[m +0000002c POP + [-1] 29 +0000002d LVAR {0x2} ; "trace" + [+1] "function trace(...) { [native code] }" +[2;40;97m [stdin]:8 [22mtrace(0);[m +00000032 LOAD8 {0} + [+2] 0 +[2;40;97m [stdin]:8 trace([22m0);[m +00000034 CALL {0x1} + [*] CALLFRAME[1] + |- stackframe 1/3 + |- ctx null +-- End -- + + +Passing an invalid trace value throws an exception. + +-- Testcase -- +{% + trace("inval"); +%} +-- End -- + +-- Expect stderr -- +Type error: Invalid level specified +In line 2, byte 15: + + ` trace("inval");` + Near here -------^ + + +-- End -- diff --git a/tests/custom/03_stdlib/40_proto b/tests/custom/03_stdlib/40_proto new file mode 100644 index 0000000..017a821 --- /dev/null +++ b/tests/custom/03_stdlib/40_proto @@ -0,0 +1,89 @@ +The `proto()` function retrievs or sets the prototype of the given object +or resource value. + +Throws an exception if given value does not support setting prototypes. + +When invoked with one argument, returns the prototype of the given value +(if any). + +When invoked with two arguments, returns the given value. + +-- Testcase -- +{% + let fs = require("fs"); + + // create a "class instance" by attaching a function dictionary to + // a plain object. + let obj = proto({}, { + greeting: function(name) { + printf("Hello, %s!\n", name); + } + }); + + // accessing a property on `obj` will look up the prototype chain + // if the object itself does not have it + obj.greeting("World"); + + printf("%.J\n", [ + // retrieve prototype of `fs.file` resource + proto(fs.stdout), + + // retrieve prototype of `obj` + proto(obj) + ]); +%} +-- End -- + +-- Expect stdout -- +Hello, World! +[ + { + "error": "function error(...) { [native code] }", + "fileno": "function fileno(...) { [native code] }", + "close": "function close(...) { [native code] }", + "tell": "function tell(...) { [native code] }", + "seek": "function seek(...) { [native code] }", + "write": "function write(...) { [native code] }", + "read": "function read(...) { [native code] }" + }, + { + "greeting": "function(name) { ... }" + } +] +-- End -- + + + +Passing an invalid value throws an exception. + +-- Testcase -- +{% + proto("inval", {}); +%} +-- End -- + +-- Expect stderr -- +Type error: Passed value is neither a prototype, resource or object +In line 2, byte 19: + + ` proto("inval", {});` + Near here -----------^ + + +-- End -- + +-- Testcase -- +{% + proto({}, "inval"); +%} +-- End -- + +-- Expect stderr -- +Type error: Passed value is neither a prototype, resource or object +In line 2, byte 19: + + ` proto({}, "inval");` + Near here -----------^ + + +-- End -- diff --git a/tests/custom/03_stdlib/41_sleep b/tests/custom/03_stdlib/41_sleep new file mode 100644 index 0000000..bca6f0d --- /dev/null +++ b/tests/custom/03_stdlib/41_sleep @@ -0,0 +1,46 @@ +The `sleep()` function pauses program execution for the given amount of +milliseconds. + +Returns `true` if the program slept. + +Returns `false` when the given time value was not convertible to an integer, +negative or zero. + +-- Testcase -- +{% + let t1 = time(); + + sleep(1000); + + let t2 = time(); + + printf("Slept for %d second(s).\n", t2 - t1); +%} +-- End -- + +-- Expect stdout -- +Slept for 1 second(s). +-- End -- + + +Passing an invalid value yields `false`. + +-- Testcase -- +{% + printf("%.J\n", [ + sleep("inval"), + sleep([]), + sleep(-1), + sleep(0) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + false, + false, + false, + false +] +-- End -- diff --git a/tests/custom/03_stdlib/42_assert b/tests/custom/03_stdlib/42_assert new file mode 100644 index 0000000..e6200e9 --- /dev/null +++ b/tests/custom/03_stdlib/42_assert @@ -0,0 +1,30 @@ +The `assert()` function raises an exception using the second argument as +message when the first argument value is not truish. + +Throws an exception if the first argument value is not truish. + +Returns the value of the first argument. + +-- Testcase -- +{% + let x = assert(123, "This should not trigger"); + printf("x = %d\n", x); + + let y = assert(false, "This should trigger"); + printf("y = %d\n", y); +%} +-- End -- + +-- Expect stdout -- +x = 123 +-- End -- + +-- Expect stderr -- +This should trigger +In line 5, byte 45: + + ` let y = assert(false, "This should trigger");` + Near here -------------------------------------^ + + +-- End -- diff --git a/tests/custom/03_stdlib/43_regexp b/tests/custom/03_stdlib/43_regexp new file mode 100644 index 0000000..9809c87 --- /dev/null +++ b/tests/custom/03_stdlib/43_regexp @@ -0,0 +1,117 @@ +The `regexp()` function compiles the given pattern string into a regular +expression, optionally applying the flags specified in the second argument. + +Throws an exception if unrecognized flag characters are specified or if the +flags argument is not a string value. + +Throws an exception if the given pattern string cannot be compiled into a +regular expression. + +Returns the compiled regexp object. + +-- Testcase -- +{% + let re1 = regexp("begin (.+) end", "i"); + let re2 = regexp("[a-z]+", "g"); + let re3 = regexp("Dots (.+) newlines", "s"); + + printf("%.J\n", [ + match("BEGIN this is some text END", re1), + match("This is a group of words", re2), + match("Dots now\ndon't\nmatch\ntext\nwith newlines", re3) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + [ + "BEGIN this is some text END", + "this is some text" + ], + [ + [ + "his" + ], + [ + "is" + ], + [ + "a" + ], + [ + "group" + ], + [ + "of" + ], + [ + "words" + ] + ], + null +] +-- End -- + + +Passing an uncompilable regexp throws an exception. + +-- Testcase -- +{% + try { + // unterminated capture group to trigger syntax error + regexp("foo("); + } + catch (e) { + // Massage compile error message for stable output since it is + // dependant on the underyling C library. + e.message = "Compile error"; + die(e); + } +%} +-- End -- + +-- Expect stderr -- +Compile error +In line 10, byte 8: + + ` die(e);` + Near here ---^ + + +-- End -- + + +Passing an invalid flags argument throws an exception. + +-- Testcase -- +{% + regexp(".*", true); +%} +-- End -- + +-- Expect stderr -- +Type error: Given flags argument is not a string +In line 2, byte 19: + + ` regexp(".*", true);` + Near here -----------^ + + +-- End -- + +-- Testcase -- +{% + regexp(".*", "igz"); +%} +-- End -- + +-- Expect stderr -- +Type error: Unrecognized flag character 'z' +In line 2, byte 20: + + ` regexp(".*", "igz");` + Near here ------------^ + + +-- End -- diff --git a/tests/custom/03_stdlib/44_wildcard b/tests/custom/03_stdlib/44_wildcard new file mode 100644 index 0000000..d838e47 --- /dev/null +++ b/tests/custom/03_stdlib/44_wildcard @@ -0,0 +1,43 @@ +The `wildcard()` function tests whether the given wildcard pattern matches +the given subject, optionally ignoring letter case. + +Returns `true` if the pattern matches the subject. + +Returns `false` if the pattern does not match the subject. + +Returns `null` if the pattern argument is not a string value. + +-- Testcase -- +{% + printf("%.J\n", [ + // A simple glob pattern match + wildcard("file.txt", "*.txt"), + + // Using `?` as single character placeholder and case folding + wildcard("2022-02-02_BACKUP.LIST", "????-??-??_backup.*", true), + + // Using bracket expressions + wildcard("aaa_123_zzz", "[a-z][a-z][a-z]_???_*"), + + // Using no meta characters at all + wildcard("test", "test"), + + // No match yields `false` + wildcard("abc", "d*"), + + // Invalid pattern value yields `null` + wildcard("true", true) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + true, + true, + true, + true, + false, + null +] +-- End -- diff --git a/tests/custom/03_stdlib/45_sourcepath b/tests/custom/03_stdlib/45_sourcepath new file mode 100644 index 0000000..92c63bf --- /dev/null +++ b/tests/custom/03_stdlib/45_sourcepath @@ -0,0 +1,69 @@ +The `sourcepath()` function determines the path of the currently executed +ucode script file, optionally only the directory portion. + +By specifying the a depth parameter, the owning files of functions further +up the call stack can be determined. + +Returns a string containing the path (or directory) of the running ucode +source file. + +Returns `null` if the path is indeterminate. + +-- Testcase -- +{% + let output = render("files/include/level1.uc"); + + // replace dynamic testfiles path with placeholder for stable output + output = replace(output, TESTFILES_PATH, "..."); + + print(output); +%} +-- End -- + +-- File include/level1.uc -- +This is the 1st level include. + +{% include("level2.uc") %} +-- End -- + +-- File include/level2.uc -- +This is the 2nd level include. + +{% include("level3.uc") %} +-- End -- + +-- File include/level3.uc -- +This is the 3rd level include. + +{% for (let depth in [0, 1, 2, 3]): %} +Depth {{ depth }}: + Path: {{ sourcepath(depth, false) || "indeterminate" }} + Directory: {{ sourcepath(depth, true) || "indeterminate" }} + +{% endfor %} +-- End -- + +-- Expect stdout -- +This is the 1st level include. + +This is the 2nd level include. + +This is the 3rd level include. + +Depth 0: + Path: .../include/level3.uc + Directory: .../include + +Depth 1: + Path: .../include/level2.uc + Directory: .../include + +Depth 2: + Path: .../include/level1.uc + Directory: .../include + +Depth 3: + Path: indeterminate + Directory: indeterminate + +-- End -- diff --git a/tests/custom/03_stdlib/46_min b/tests/custom/03_stdlib/46_min new file mode 100644 index 0000000..c07fbff --- /dev/null +++ b/tests/custom/03_stdlib/46_min @@ -0,0 +1,28 @@ +The `min()` function returns the minimum of all given arguments. + +If multiple equivalent minimum values are given (e.g. `null` and `false` +both are treated as `0` when comparing numerically), the first minimal +value is returned. + +Returns the minimum value among all given arguments or `null` if no +arguments were passed. + +-- Testcase -- +{% + printf("%.J\n", [ + min(), + min(5, 1, 3, -10), + min("foo", "bar", "xxx", "abc"), + min(false, null, 0, NaN) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + null, + -10, + "abc", + false +] +-- End -- diff --git a/tests/custom/03_stdlib/47_max b/tests/custom/03_stdlib/47_max new file mode 100644 index 0000000..69e6fb8 --- /dev/null +++ b/tests/custom/03_stdlib/47_max @@ -0,0 +1,28 @@ +The `max()` function returns the maximum of all given arguments. + +If multiple equivalent maximum values are given (e.g. `null` and `false` +both are treated as `0` when comparing numerically), the first maximal +value is returned. + +Returns the maximum value among all given arguments or `null` if no +arguments were passed. + +-- Testcase -- +{% + printf("%.J\n", [ + max(), + max(5, 1, 3, -10), + max("foo", "bar", "xxx", "abc"), + max(false, null, 0, NaN) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + null, + 5, + "xxx", + false +] +-- End -- diff --git a/tests/custom/03_stdlib/48_b64dec b/tests/custom/03_stdlib/48_b64dec new file mode 100644 index 0000000..898aa7a --- /dev/null +++ b/tests/custom/03_stdlib/48_b64dec @@ -0,0 +1,31 @@ +The `b64dec()` function decodes the given base64 input string. + +Returns a string containing the decoded data. + +Returns `null` if the input is not a string or if the input string was +invalid base64 data (e.g. missing padding or non-whitespace characters +outside the expected alphabet). + +-- Testcase -- +{% + printf("%.J\n", [ + b64dec("SGVsbG8sIHdvcmxkIQ=="), + b64dec("SGVsbG8sIHdvcmxkIQ"), + b64dec("AAECAw=="), + b64dec("xxx"), + b64dec("==="), + b64dec(true) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "Hello, world!", + null, + "\u0000\u0001\u0002\u0003", + null, + null, + null +] +-- End -- diff --git a/tests/custom/03_stdlib/49_b64enc b/tests/custom/03_stdlib/49_b64enc new file mode 100644 index 0000000..3ef0381 --- /dev/null +++ b/tests/custom/03_stdlib/49_b64enc @@ -0,0 +1,25 @@ +The `b64enc()` function encodes the given input string as base64. + +Returns a string containing the encoded data. + +Returns `null` if the input is not a string. + +-- Testcase -- +{% + printf("%.J\n", [ + b64enc("Hello, world!"), + b64enc("\u0000\u0001\u0002\u0003"), + b64enc(""), + b64enc(true) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + "SGVsbG8sIHdvcmxkIQ==", + "AAECAw==", + "", + null +] +-- End -- diff --git a/tests/custom/03_stdlib/50_uniq b/tests/custom/03_stdlib/50_uniq new file mode 100644 index 0000000..6e13077 --- /dev/null +++ b/tests/custom/03_stdlib/50_uniq @@ -0,0 +1,66 @@ +The `uniq()` function extracts the unique set of all values within the +given input array, maintaining the original order. + +Returns an array containing all unique items of the input array. + +Returns `null` if the input is not an array value. + +-- Testcase -- +{% + let o1 = { an: "object" }; + let o2 = { an: "object" }; // same but not identical + + let a1 = [ 1, 2, 3 ]; + let a2 = [ 1, 2, 3 ]; // same but not identical + + printf("%.J\n", [ + // strict comparison is used, 0 and "0" are not unique + uniq([ 0, 1, 2, 0, "0", 2, 3, "4", 4 ]), + + // despite NaN != NaN, two NaN values are not unique + uniq([ NaN, NaN ]), + + // only identical objects are filtered, not equivalent ones + uniq([ o1, o1, o2, a1, a1, a2 ]), + + // invalid input yields `null` + uniq(true) + ]); +%} +-- End -- + +-- Expect stdout -- +[ + [ + 0, + 1, + 2, + "0", + 3, + "4", + 4 + ], + [ + "NaN" + ], + [ + { + "an": "object" + }, + { + "an": "object" + }, + [ + 1, + 2, + 3 + ], + [ + 1, + 2, + 3 + ] + ], + null +] +-- End -- |