3 |
2 |
3 |
10 | 
11 |
", message: "Can read n bytes");
40 |
41 | file.close();
42 | }
43 |
--------------------------------------------------------------------------------
/tests/023-std.buzz:
--------------------------------------------------------------------------------
1 | import "std";
2 |
3 | test "std\parseInt/Double" {
4 | std\assert(std\parseInt("12") == 12, message: "Could parse int");
5 | std\assert(std\parseDouble("12.42") == 12.42, message: "Could parse double");
6 | std\assert(std\parseInt("not a number") == null, message: "Doesn't parse stupid shit");
7 |
8 | std\assert(std\toInt(23.34) == 23, message: "Could cast double to int");
9 | std\assert(std\toDouble(23) == 23.0, message: "Could cast int to double");
10 | std\assert(std\toUd(23) is ud, message: "Could cast int to ud");
11 | std\assert(std\toUd(23.0) is ud, message: "Could cast double to ud");
12 |
13 | std\assert(std\parseUd("42") == std\toUd(42), message: "Could parse ud");
14 | }
15 |
16 | test "char" {
17 | std\assert(std\char(65) == "A", message: "char");
18 | }
19 |
20 | test "random" {
21 | std\assert(std\random(min: 5, max: 10) >= 5, message: "random range");
22 | std\assert(std\random(max: 10) <= 10, message: "random range");
23 | }
24 |
--------------------------------------------------------------------------------
/tests/024-os.buzz:
--------------------------------------------------------------------------------
1 | import "std";
2 | import "os" as os;
3 |
4 | test "os\env" {
5 | std\assert(os\env("HOME") != null, message: "could get env variable");
6 | }
7 |
8 | test "os\time" {
9 | std\assert(os\time() > 0, message: "Got time");
10 | }
11 |
12 | test "os\tmpDir" {
13 | // TODO: replace by .len check
14 | std\assert(os\tmpDir() != "", message: "Got system tmp dir");
15 | }
16 |
17 | test "os\tmpFilename" {
18 | std\assert(os\tmpFilename("buzz_test") != "", message: "Got tmp file name");
19 | }
20 |
21 | test "os\execute" {
22 | std\assert(os\execute([ "./zig-out/bin/buzz", "--version" ]) == 0, message: "Could execute a command");
23 | }
24 |
25 | test "os\sleep" {
26 | os\sleep(500.0);
27 | }
28 |
--------------------------------------------------------------------------------
/tests/025-fs.buzz:
--------------------------------------------------------------------------------
1 | import "std";
2 | import "fs" as fs;
3 |
4 | test "fs\cwd" {
5 | std\assert(fs\currentDirectory() != "", message: "Could get cwd");
6 | }
7 |
8 | test "mkDir/rm" {
9 | fs\makeDirectory("yo");
10 | fs\makeDirectory("{fs\currentDirectory()}/yo2");
11 |
12 | fs\delete("yo");
13 | fs\delete("{fs\currentDirectory()}/yo2");
14 | }
15 |
16 | test "ls" {
17 | var containsREADME = false;
18 | foreach (el in fs\list(fs\currentDirectory())) {
19 | _ = "hello there!";
20 | if (el == "README.md") {
21 | containsREADME = true;
22 | break;
23 | }
24 | }
25 |
26 | final anotherRandomLocal = "bye there!";
27 |
28 | std\assert(anotherRandomLocal == "bye there!", message: "foreach break is wrong");
29 |
30 | std\assert(containsREADME, message: "Could list element in current directory");
31 |
32 | foreach (el in fs\list("/doesnotexist") catch [ "wentwrong" ]) {
33 | std\assert(el == "wentwrong", message: "Trying to list a non existent directory raised an error");
34 | }
35 |
36 | std\assert(fs\exists("README.md"), message: "fs\\exists");
37 | }
38 |
39 | test "move" {
40 | fs\move(source: "README.md", destination: "src/README.md");
41 |
42 | std\assert(
43 | fs\list("src").indexOf("README.md") != null,
44 | message: "Moved file to expected location",
45 | );
46 |
47 | fs\move(source: "src/README.md", destination: "README.md");
48 |
49 | std\assert(
50 | fs\list(".").indexOf("README.md") != null,
51 | message: "Moved file to expected location",
52 | );
53 | }
54 |
--------------------------------------------------------------------------------
/tests/026-break-continue.buzz:
--------------------------------------------------------------------------------
1 | import "std";
2 |
3 | test "break statement" {
4 | var i = 0;
5 | while (i < 10) {
6 | i = i + 1;
7 |
8 | if (i == 3) {
9 | break;
10 | }
11 | }
12 |
13 | std\assert(i == 3, message: "break");
14 | }
15 |
16 | test "continue statement" {
17 | var i = 0;
18 | while (i < 10) {
19 | i = i + 1;
20 |
21 | if (i == 3) {
22 | continue;
23 | }
24 |
25 | i = i + 1;
26 | }
27 |
28 | std\assert(i == 11, message: "break");
29 | }
30 |
--------------------------------------------------------------------------------
/tests/027-run-file.buzz:
--------------------------------------------------------------------------------
1 | import "std";
2 | import "io";
3 |
4 | test "runFile" {
5 | io\runFile("tests/utils/testing.buzz");
6 |
7 | std\assert(true, message: "Could run a buzz file");
8 | }
9 |
10 | test "run non existent file" {
11 | var errorRaised = false;
12 | try {
13 | io\runFile("tests/utils/testingsldkfj.buzz");
14 | } catch {
15 | errorRaised = true;
16 | }
17 |
18 | std\assert(errorRaised, message: "Non existent file raised an error");
19 | }
20 |
--------------------------------------------------------------------------------
/tests/028-math.buzz:
--------------------------------------------------------------------------------
1 | import "std";
2 | import "math" as math;
3 |
4 | test "math" {
5 | std\assert(math\abs(-12.234) == 12.234, message: "math\\abs");
6 | std\assert(math\acos(0.1) == 1.4706289056333368, message: "math\\acos");
7 | std\assert(math\asin(0.1) == 0.1001674211615598, message: "math\\asin");
8 | std\assert(math\atan(0.1) == 0.09966865249116204, message: "math\\atan");
9 | std\assert(math\ceil(12.234) == 13, message: "math\\ceil");
10 | std\assert(math\cos(12.234) == 0.9452715049027691, message: "math\\cos");
11 | std\assert(math\exp(12.234) == 205664.19575705, message: "math\\exp");
12 | std\assert(math\floor(12.234) == 12, message: "math\\floor");
13 | std\assert(math\sin(12.234) == -0.3262848173281347, message: "math\\sin");
14 | std\assert(math\sqrt(12.234) == 3.4977135388707863, message: "math\\sqrt");
15 | std\assert(math\tan(12.234) == -0.34517576763481983, message: "math\\tan");
16 |
17 | std\assert(math\minInt(a: 12, b: 124) == 12, message: "math\\min");
18 | std\assert(math\maxInt(a: 12, b: 124) == 124, message: "math\\max");
19 |
20 | std\assert(math\deg(2.0) == 114.59155902616439, message: "math\\deg");
21 | std\assert(math\rad(math\deg(2.0)) == 2, message: "math\\rad");
22 | }
23 |
--------------------------------------------------------------------------------
/tests/029-default-arguments.buzz:
--------------------------------------------------------------------------------
1 | import "std";
2 |
3 | fun hey(name: str = "Joe", age: int = 12, father: str?, fourth: int = 1) > str => "Hello {name} you're {age} {father} {fourth}";
4 |
5 | test "function default arguments" {
6 | std\assert(hey("John") == "Hello John you're 12 null 1", message: "Could reorder or omit argument");
7 | std\assert(hey(age: 25) == "Hello Joe you're 25 null 1", message: "Could reorder or omit argument");
8 | std\assert(hey(father: "Doe") == "Hello Joe you're 12 Doe 1", message: "Could reorder or omit argument");
9 | std\assert(hey(fourth: 42) == "Hello Joe you're 12 null 42", message: "Could reorder or omit argument");
10 | std\assert(hey(fourth: 12, age: 44) == "Hello Joe you're 44 null 12", message: "Could reorder or omit argument");
11 | }
12 |
--------------------------------------------------------------------------------
/tests/030-str.buzz:
--------------------------------------------------------------------------------
1 | import "std";
2 |
3 | test "str subscript" {
4 | std\assert("hello world"[1] == "e", message: "str subscript");
5 | }
6 |
7 | test "str.len" {
8 | std\assert("hello world".len() == 11, message: "str.len");
9 | }
10 |
11 | test "str.byte" {
12 | std\assert("hello world".byte(1) == 101, message: "str.byte");
13 | }
14 |
15 | test "str.indexOf" {
16 | std\assert("hello world".indexOf("world") == 6, message: "str.indexOf");
17 | std\assert("hello world".indexOf("moon") == null, message: "str.indexOf");
18 | }
19 |
20 | test "str.split" {
21 | final splits = "one,two,three".split(",");
22 |
23 | std\assert(splits[0] == "one" and splits[1] == "two" and splits[2] == "three", message: "str.split");
24 | }
25 |
26 | test "str.sub" {
27 | std\assert("hello world".sub(6) == "world", message: "str.sub");
28 | std\assert("hello world".sub(0, len: 5) == "hello", message: "str.sub");
29 | }
30 |
31 | test "base64" {
32 | std\assert("hello world".encodeBase64() == "aGVsbG8gd29ybGQ=", message: "could encode in b64");
33 | std\assert("aGVsbG8gd29ybGQ=".decodeBase64() == "hello world", message: "could encode in b64");
34 | }
35 |
36 | test "upper/lower" {
37 | std\assert("hello world!".upper() == "HELLO WORLD!", message: "upper");
38 | std\assert("HellO WorlD!".lower() == "hello world!", message: "lower");
39 | }
40 |
41 | test "hex/bin" {
42 | std\assert("c3fcd3d76192e4007dfb496cca67e13b".bin().hex() == "c3fcd3d76192e4007dfb496cca67e13b", message: "hex/bin");
43 | }
44 |
45 | test "trim" {
46 | std\assert(" hello world \t\n".trim() == "hello world", message: "could trim str");
47 | }
48 |
--------------------------------------------------------------------------------
/tests/031-json.buzz:
--------------------------------------------------------------------------------
1 | import "std";
2 | import "serialize";
3 |
4 | test "Json.encode" {
5 | final data = {
6 | "hello": "world",
7 | "bye": 42,
8 | };
9 |
10 | std\assert(
11 | serialize\jsonEncode(serialize\Boxed.init(data)) == `\{"hello":"world","bye":42}`,
12 | message: "valid encode",
13 | );
14 | }
15 |
16 | test "Json.decode" {
17 | std\assert(
18 | serialize\jsonDecode(`[ -12, true, "hello" ]`).listValue()[2].string() == "hello",
19 | message: "could decode simple JSON",
20 | );
21 | }
22 |
23 | test "Boxed.q" {
24 | final data = {
25 | "submap": {
26 |