2020-10-20 00:56:51 +03:00
# Unit tests for builtin functions
2021-08-02 00:49:24 +03:00
```ucm:hide
2024-06-12 01:22:09 +03:00
scratch/main> builtins.mergeio
scratch/main> load unison-src/transcripts-using-base/base.u
scratch/main> add
2021-08-02 00:49:24 +03:00
```
2024-06-12 01:22:09 +03:00
This transcript defines unit tests for builtin functions. There's a single `scratch/main> test` execution at the end that will fail the transcript with a nice report if any of the tests fail.
2020-10-20 18:08:18 +03:00
2020-10-20 17:55:57 +03:00
## `Int` functions
```unison:hide
use Int
2022-12-20 19:29:02 +03:00
-- used for some take/drop tests later
bigN = Nat.shiftLeft 1 63
2020-10-20 18:08:18 +03:00
-- Note: you can make the tests more fine-grained if you
-- want to be able to tell which one is failing
2020-10-20 17:55:57 +03:00
test> Int.tests.arithmetic =
checks [
2021-12-16 01:07:39 +03:00
eq (+1 + +1) +2,
2020-10-20 17:55:57 +03:00
+10 - +4 == +6,
2021-12-16 01:07:39 +03:00
eq (+11 * +6) +66,
eq (+11 * +6) +66,
2020-10-20 17:55:57 +03:00
+10 / +3 == +3,
+10 / +5 == +2,
2021-12-16 01:07:39 +03:00
mod +10 +3 == +1,
mod +10 +2 == +0,
mod -13 +3 == +2,
mod -13 -3 == -1,
mod -13 -5 == -3,
mod -13 +5 == +2,
2020-10-20 17:55:57 +03:00
negate +99 == -99,
increment +99 == +100,
not (isEven +99),
isEven +100,
isOdd +105,
not (isOdd +108),
signum +99 == +1,
signum -3949 == -1,
signum +0 == +0,
2021-12-16 01:07:39 +03:00
gt +42 -1,
lt +42 +1000,
lteq +43 +43,
lteq +43 +44,
gteq +43 +43,
gteq +43 +41
2020-10-20 17:55:57 +03:00
]
test> Int.tests.bitTwiddling =
checks [
2021-12-16 01:07:39 +03:00
and +5 +4 == +4,
and +5 +1 == +1,
or +4 +1 == +5,
xor +5 +1 == +4,
2020-10-20 17:55:57 +03:00
complement -1 == +0,
popCount +1 == 1,
popCount +2 == 1,
popCount +4 == 1,
popCount +5 == 2,
popCount -1 == 64,
leadingZeros +1 == 63,
trailingZeros +1 == 0,
leadingZeros +2 == 62,
trailingZeros +2 == 1,
pow +2 6 == +64,
shiftLeft +1 6 == +64,
shiftRight +64 6 == +1
]
test> Int.tests.conversions =
checks [
truncate0 -2438344 == 0,
truncate0 +999 == 999,
toText +0 == "0",
toText +10 == "10",
toText -1039 == "-1039",
fromText "+0" == Some +0,
2021-08-04 17:42:35 +03:00
fromText "a8f9djasdlfkj" == None,
2020-10-20 17:55:57 +03:00
fromText "3940" == Some +3940,
2023-01-24 22:37:34 +03:00
fromText "1000000000000000000000000000" == None,
fromText "-1000000000000000000000000000" == None,
2020-10-20 17:55:57 +03:00
toFloat +9394 == 9394.0,
toFloat -20349 == -20349.0
]
```
```ucm:hide
2024-06-12 01:22:09 +03:00
scratch/main> add
2020-10-20 17:55:57 +03:00
```
## `Nat` functions
2020-10-20 00:56:51 +03:00
```unison:hide
2020-10-20 17:55:57 +03:00
use Nat
test> Nat.tests.arithmetic =
checks [
2021-12-16 01:07:39 +03:00
eq (1 + 1) 2,
drop 10 4 == 6,
sub 10 12 == -2,
eq (11 * 6) 66,
2020-10-20 17:55:57 +03:00
10 / 3 == 3,
10 / 5 == 2,
2021-12-16 01:07:39 +03:00
mod 10 3 == 1,
mod 10 2 == 0,
2021-07-15 18:02:49 +03:00
18446744073709551615 / 2 == 9223372036854775807,
2021-12-16 01:07:39 +03:00
mod 18446744073709551615 2 == 1,
2020-10-20 17:55:57 +03:00
increment 99 == 100,
not (isEven 99),
isEven 100,
isOdd 105,
not (isOdd 108),
2021-12-16 01:07:39 +03:00
gt 42 1,
lt 42 1000,
lteq 43 43,
lteq 43 44,
gteq 43 43,
gteq 43 41,
2020-10-20 17:55:57 +03:00
]
test> Nat.tests.bitTwiddling =
checks [
2021-12-16 01:07:39 +03:00
and 5 4 == 4,
and 5 1 == 1,
or 4 1 == 5,
xor 5 1 == 4,
2020-10-20 17:55:57 +03:00
complement (complement 0) == 0,
popCount 1 == 1,
popCount 2 == 1,
popCount 4 == 1,
popCount 5 == 2,
popCount (complement 0) == 64,
leadingZeros 1 == 63,
trailingZeros 1 == 0,
leadingZeros 2 == 62,
trailingZeros 2 == 1,
pow 2 6 == 64,
shiftLeft 1 6 == 64,
shiftRight 64 6 == 1
]
test> Nat.tests.conversions =
checks [
toFloat 2438344 == 2438344.0,
toFloat 0 == 0.0,
toText 0 == "0",
toText 32939 == "32939",
toText 10 == "10",
2021-08-04 17:42:35 +03:00
fromText "ooga" == None,
2021-05-12 20:59:41 +03:00
fromText "90" == Some 90,
2023-01-24 22:37:34 +03:00
fromText "-1" == None,
fromText "100000000000000000000000000" == None,
2021-05-12 20:59:41 +03:00
unsnoc "abc" == Some ("ab", ?c),
uncons "abc" == Some (?a, "bc"),
unsnoc "" == None,
2021-11-02 23:56:50 +03:00
uncons "" == None,
Text.fromCharList (Text.toCharList "abc") == "abc",
Bytes.fromList (Bytes.toList 0xsACE0BA5E) == 0xsACE0BA5E
2020-10-20 17:55:57 +03:00
]
2020-10-20 00:56:51 +03:00
```
```ucm:hide
2024-06-12 01:22:09 +03:00
scratch/main> add
2020-10-20 00:56:51 +03:00
```
2021-05-06 03:20:41 +03:00
## `Boolean` functions
```unison:hide
test> Boolean.tests.orTable =
checks [
2024-08-18 05:02:41 +03:00
(true || true) == true,
(true || false) == true,
(false || true) == true,
(false || false) == false
2021-05-06 03:20:41 +03:00
]
test> Boolean.tests.andTable =
checks [
2024-08-18 05:02:41 +03:00
(true & & true) == true,
(false & & true) == false,
(true & & false) == false,
(false & & false) == false
2021-05-06 03:20:41 +03:00
]
test> Boolean.tests.notTable =
checks [
not true == false,
not false == true
]
```
```ucm:hide
2024-06-12 01:22:09 +03:00
scratch/main> add
2021-05-06 03:20:41 +03:00
```
2021-04-08 21:02:27 +03:00
## `Text` functions
```unison:hide
test> Text.tests.takeDropAppend =
checks [
"yabba" ++ "dabba" == "yabbadabba",
Text.take 0 "yabba" == "",
Text.take 2 "yabba" == "ya",
Text.take 99 "yabba" == "yabba",
Text.drop 0 "yabba" == "yabba",
Text.drop 2 "yabba" == "bba",
2022-12-20 19:29:02 +03:00
Text.drop 99 "yabba" == "",
Text.take bigN "yabba" == "yabba",
Text.drop bigN "yabba" == ""
2021-04-08 21:02:27 +03:00
]
test> Text.tests.repeat =
checks [
Text.repeat 4 "o" == "oooo",
Text.repeat 0 "o" == ""
]
test> Text.tests.alignment =
checks [
Text.alignLeftWith 5 ?\s "a" == "a ",
Text.alignRightWith 5 ?_ "ababa" == "ababa",
Text.alignRightWith 5 ?_ "ab" == "___ab"
]
2022-02-18 17:14:33 +03:00
test> Text.tests.literalsEq = checks [":)" == ":)"]
2022-07-01 20:51:59 +03:00
test> Text.tests.patterns =
use Pattern many or run isMatch capture join replicate
use Text.patterns literal digit letter anyChar space punctuation notCharIn charIn charRange notCharRange eof
l = literal
checks [
run digit "1abc" == Some ([], "abc"),
run (capture (many digit)) "11234abc" == Some (["11234"], "abc"),
run (many letter) "abc11234abc" == Some ([], "11234abc"),
run (join [many space, capture (many anyChar)]) " abc123" == Some (["abc123"], ""),
run (many punctuation) "!!!!,,,..." == Some ([], ""),
run (charIn [?0,?1]) "0" == Some ([], ""),
run (notCharIn [?0,?1]) "0" == None,
run (many (notCharIn [?0,?1])) "asjdfskdfjlskdjflskdjf011" == Some ([], "011"),
run (capture (many (charRange ?a ?z))) "hi123" == Some (["hi"], "123"),
run (capture (many (notCharRange ?, ?,))) "abc123," == Some (["abc123"], ","),
run (capture (many (notCharIn [?,,]))) "abracadabra,123" == Some (["abracadabra"], ",123"),
2022-07-01 21:07:19 +03:00
run (capture (many (or digit letter))) "11234abc,remainder" == Some (["11234abc"], ",remainder"),
2022-07-01 21:47:08 +03:00
run (capture (replicate 1 5 (or digit letter))) "1a2ba aaa" == Some (["1a2ba"], " aaa"),
2023-05-09 02:31:59 +03:00
run (captureAs "foo" (many (or digit letter))) "11234abc,remainder" == Some (["foo"], ",remainder"),
run (join [(captureAs "foo" (many digit)), captureAs "bar" (many letter)]) "11234abc,remainder" == Some (["foo", "bar"], ",remainder"),
2022-10-26 17:27:12 +03:00
-- Regression test for: https://github.com/unisonweb/unison/issues/3530
run (capture (replicate 0 1 (join [literal "a", literal "b"]))) "ac" == Some ([""], "ac"),
2022-07-01 21:47:08 +03:00
isMatch (join [many letter, eof]) "aaaaabbbb" == true,
isMatch (join [many letter, eof]) "aaaaabbbb1" == false,
2022-07-01 20:51:59 +03:00
isMatch (join [l "abra", many (l "cadabra")]) "abracadabracadabra" == true,
]
2023-06-02 05:24:07 +03:00
test> Text.tests.indexOf =
haystack = "01020304" ++ "05060708" ++ "090a0b0c01"
needle1 = "01"
needle2 = "02"
needle3 = "0304"
needle4 = "05"
needle5 = "0405"
needle6 = "0c"
needle7 = haystack
needle8 = "lopez"
2023-06-15 22:19:45 +03:00
needle9 = ""
2023-06-02 05:24:07 +03:00
checks [
Text.indexOf needle1 haystack == Some 0,
Text.indexOf needle2 haystack == Some 2,
Text.indexOf needle3 haystack == Some 4,
Text.indexOf needle4 haystack == Some 8,
Text.indexOf needle5 haystack == Some 6,
Text.indexOf needle6 haystack == Some 22,
Text.indexOf needle7 haystack == Some 0,
Text.indexOf needle8 haystack == None,
2023-06-15 22:19:45 +03:00
Text.indexOf needle9 haystack == Some 0,
2023-06-02 05:24:07 +03:00
]
2024-04-29 04:30:02 +03:00
test> Text.tests.indexOfEmoji =
2023-06-13 00:39:04 +03:00
haystack = "clap 👏 your 👏 hands 👏 if 👏 you 👏 love 👏 unison"
needle1 = "👏"
needle2 = "👏 "
checks [
Text.indexOf needle1 haystack == Some 5,
Text.indexOf needle2 haystack == Some 5,
]
2023-06-02 05:24:07 +03:00
2021-04-08 21:02:27 +03:00
```
```ucm:hide
2024-06-12 01:22:09 +03:00
scratch/main> add
2021-04-08 21:02:27 +03:00
```
2021-04-24 21:09:59 +03:00
## `Bytes` functions
2021-04-24 22:59:12 +03:00
```unison:hide
2021-04-24 21:09:59 +03:00
test> Bytes.tests.at =
bs = Bytes.fromList [77, 13, 12]
checks [
2021-04-24 22:59:12 +03:00
Bytes.at 1 bs == Some 13,
Bytes.at 0 bs == Some 77,
2022-12-20 19:29:02 +03:00
Bytes.at 99 bs == None,
Bytes.take bigN bs == bs,
Bytes.drop bigN bs == empty
2021-04-24 21:09:59 +03:00
]
2021-08-14 04:10:44 +03:00
test> Bytes.tests.compression =
roundTrip b =
(Bytes.zlib.decompress (Bytes.zlib.compress b) == Right b)
& & (Bytes.gzip.decompress (Bytes.gzip.compress b) == Right b)
checks [
roundTrip 0xs2093487509823745709827345789023457892345,
roundTrip 0xs00000000000000000000000000000000000000000000,
roundTrip 0xs,
roundTrip 0xs11111111111111111111111111,
roundTrip 0xsffffffffffffffffffffffffffffff,
roundTrip 0xs222222222fffffffffffffffffffffffffffffff,
-- these fail due to bad checksums and/or headers
isLeft (zlib.decompress 0xs2093487509823745709827345789023457892345),
isLeft (gzip.decompress 0xs201209348750982374593939393939709827345789023457892345)
]
2022-10-13 18:27:26 +03:00
2022-10-26 17:27:12 +03:00
test> Bytes.tests.fromBase64UrlUnpadded =
2022-10-13 18:27:26 +03:00
checks [Exception.catch
'(fromUtf8
(raiseMessage () (Bytes.fromBase64UrlUnpadded (toUtf8 "aGVsbG8gd29ybGQ")))) == Right "hello world"
, isLeft (Bytes.fromBase64UrlUnpadded (toUtf8 "aGVsbG8gd29ybGQ="))]
2022-10-26 17:27:12 +03:00
2023-06-02 05:24:07 +03:00
test> Bytes.tests.indexOf =
haystack = 0xs01020304 ++ 0xs05060708 ++ 0xs090a0b0c01
needle1 = 0xs01
needle2 = 0xs02
needle3 = 0xs0304
needle4 = 0xs05
needle5 = 0xs0405
needle6 = 0xs0c
needle7 = haystack
needle8 = 0xsffffff
checks [
Bytes.indexOf needle1 haystack == Some 0,
Bytes.indexOf needle2 haystack == Some 1,
Bytes.indexOf needle3 haystack == Some 2,
Bytes.indexOf needle4 haystack == Some 4,
Bytes.indexOf needle5 haystack == Some 3,
Bytes.indexOf needle6 haystack == Some 11,
Bytes.indexOf needle7 haystack == Some 0,
Bytes.indexOf needle8 haystack == None,
]
2021-04-24 21:09:59 +03:00
```
```ucm:hide
2024-06-12 01:22:09 +03:00
scratch/main> add
2021-04-24 21:09:59 +03:00
```
2022-11-15 20:14:18 +03:00
## `List` comparison
```unison:hide
test> checks [
compare [] [1,2,3] == -1,
compare [1,2,3] [1,2,3,4] == -1,
compare [1,2,3,4] [1,2,3] == +1,
compare [1,2,3] [1,2,3] == +0,
compare [3] [1,2,3] == +1,
compare [1,2,3] [1,2,4] == -1,
compare [1,2,2] [1,2,1,2] == +1,
compare [1,2,3,4] [3,2,1] == -1
]
```
```ucm:hide
2024-06-12 01:22:09 +03:00
scratch/main> add
2022-11-15 20:14:18 +03:00
```
2022-12-20 19:29:02 +03:00
Other list functions
```unison:hide
test> checks [
List.take bigN [1,2,3] == [1,2,3],
List.drop bigN [1,2,3] == []
]
```
2020-12-10 22:25:19 +03:00
## `Any` functions
```unison
> [Any "hi", Any (41 + 1)]
2021-02-24 10:56:04 +03:00
test> Any.test1 = checks [(Any "hi" == Any "hi")]
test> Any.test2 = checks [(not (Any "hi" == Any 42))]
2020-12-10 22:25:19 +03:00
```
```ucm:hide
2024-06-12 01:22:09 +03:00
scratch/main> add
2020-12-10 22:25:19 +03:00
```
2022-01-26 19:43:41 +03:00
## Sandboxing functions
```unison
2022-02-16 22:40:04 +03:00
openFile1 t = openFile t
openFile2 t = openFile1 t
2023-10-23 19:45:02 +03:00
validateSandboxedSimpl ok v =
match Value.validateSandboxed ok v with
Right [] -> true
_ -> false
2022-02-16 22:40:04 +03:00
openFiles =
[ not (validateSandboxed [] openFile)
, not (validateSandboxed [] openFile1)
, not (validateSandboxed [] openFile2)
]
2022-01-26 19:43:41 +03:00
test> Sandbox.test1 = checks [validateSandboxed [] "hello"]
2022-02-16 22:40:04 +03:00
test> Sandbox.test2 = checks openFiles
2022-01-26 19:43:41 +03:00
test> Sandbox.test3 = checks [validateSandboxed [termLink openFile.impl]
openFile]
```
```ucm:hide
2024-06-12 01:22:09 +03:00
scratch/main> add
2022-01-26 19:43:41 +03:00
```
2023-10-23 19:45:02 +03:00
```unison
openFilesIO = do
checks
[ not (validateSandboxedSimpl [] (value openFile))
, not (validateSandboxedSimpl [] (value openFile1))
, not (validateSandboxedSimpl [] (value openFile2))
, sandboxLinks (termLink openFile)
== sandboxLinks (termLink openFile1)
, sandboxLinks (termLink openFile1)
== sandboxLinks (termLink openFile2)
]
```
```ucm
2024-06-12 01:22:09 +03:00
scratch/main> add
scratch/main> io.test openFilesIO
2023-10-23 19:45:02 +03:00
```
2023-01-24 02:36:33 +03:00
## Universal hash functions
Just exercises the function
```unison
2023-01-24 03:58:03 +03:00
> Universal.murmurHash 1
2023-01-25 04:10:11 +03:00
test> Universal.murmurHash.tests = checks [Universal.murmurHash [1,2,3] == Universal.murmurHash [1,2,3]]
2023-01-24 02:36:33 +03:00
```
```ucm:hide
2024-06-12 01:22:09 +03:00
scratch/main> add
2023-01-24 02:36:33 +03:00
```
2020-10-20 00:56:51 +03:00
## Run the tests
2020-10-20 18:08:18 +03:00
Now that all the tests have been added to the codebase, let's view the test report. This will fail the transcript (with a nice message) if any of the tests are failing.
2020-10-20 00:56:51 +03:00
```ucm
2024-06-12 01:22:09 +03:00
scratch/main> test
2020-10-20 00:56:51 +03:00
```