mirror of
https://github.com/roc-lang/roc.git
synced 2025-09-27 13:59:08 +00:00
1063 lines
25 KiB
Rust
1063 lines
25 KiB
Rust
#[macro_use]
|
|
extern crate pretty_assertions;
|
|
|
|
#[macro_use]
|
|
extern crate indoc;
|
|
|
|
extern crate bumpalo;
|
|
extern crate libc;
|
|
|
|
#[macro_use]
|
|
mod helpers;
|
|
|
|
#[cfg(all(test, any(target_os = "linux", target_os = "macos"), any(target_arch = "x86_64"/*, target_arch = "aarch64"*/)))]
|
|
mod wasm_num {
|
|
#[test]
|
|
fn i64_values() {
|
|
assert_evals_to!("0", 0, i64);
|
|
assert_evals_to!("-0", 0, i64);
|
|
assert_evals_to!("-1", -1, i64);
|
|
assert_evals_to!("1", 1, i64);
|
|
assert_evals_to!("9_000_000_000_000", 9_000_000_000_000, i64);
|
|
assert_evals_to!("-9_000_000_000_000", -9_000_000_000_000, i64);
|
|
assert_evals_to!("0b1010", 0b1010, i64);
|
|
assert_evals_to!("0o17", 0o17, i64);
|
|
assert_evals_to!("0x1000_0000_0000_0000", 0x1000_0000_0000_0000, i64);
|
|
}
|
|
|
|
#[test]
|
|
fn f64_values() {
|
|
assert_evals_to!("0.0", 0.0, f64);
|
|
assert_evals_to!("-0.0", 0.0, f64);
|
|
assert_evals_to!("1.0", 1.0, f64);
|
|
assert_evals_to!("-1.0", -1.0, f64);
|
|
assert_evals_to!("3.1415926535897932", 3.141_592_653_589_793, f64);
|
|
assert_evals_to!(&format!("{:0.1}", f64::MIN), f64::MIN, f64);
|
|
assert_evals_to!(&format!("{:0.1}", f64::MAX), f64::MAX, f64);
|
|
}
|
|
|
|
#[test]
|
|
fn i8_add_wrap() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x : I8
|
|
x = 0x7f + 0x7f
|
|
|
|
x
|
|
"#
|
|
),
|
|
-2,
|
|
i8
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn i16_add_wrap() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x : I16
|
|
x = 0x7fff + 0x7fff
|
|
|
|
x
|
|
"#
|
|
),
|
|
-2,
|
|
i16
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn i32_add_wrap() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x : I32
|
|
x = 0x7fffffff + 0x7fffffff
|
|
|
|
x
|
|
"#
|
|
),
|
|
-2,
|
|
i32
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn u8_add_wrap() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x : U8
|
|
x = 0xff + 0xff
|
|
|
|
x
|
|
"#
|
|
),
|
|
0xfe,
|
|
u8
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn u16_add_wrap() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x : U16
|
|
x = 0xffff + 0xffff
|
|
|
|
x
|
|
"#
|
|
),
|
|
0xfffe,
|
|
u16
|
|
);
|
|
}
|
|
#[test]
|
|
fn u32_add_wrap() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x : U32
|
|
x = 0xffffffff + 0xffffffff
|
|
|
|
x
|
|
"#
|
|
),
|
|
0xfffffffe,
|
|
u32
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_add_i64() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
1 + 2 + 3
|
|
"#
|
|
),
|
|
6,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn if_then_else() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
cond : Bool
|
|
cond = True
|
|
|
|
if cond then
|
|
0
|
|
else
|
|
1
|
|
"#
|
|
),
|
|
0,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn rgb_red() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when Red is
|
|
Red -> 111
|
|
Green -> 222
|
|
Blue -> 333
|
|
"#
|
|
),
|
|
111,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn rgb_green() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when Green is
|
|
Red -> 111
|
|
Green -> 222
|
|
Blue -> 333
|
|
"#
|
|
),
|
|
222,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn rgb_blue() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
when Blue is
|
|
Red -> 111
|
|
Green -> 222
|
|
Blue -> 333
|
|
"#
|
|
),
|
|
333,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn join_point() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
x = if True then 111 else 222
|
|
|
|
x + 123
|
|
"#
|
|
),
|
|
234,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn factorial() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
app "test" provides [ main ] to "./platform"
|
|
|
|
fac : I32, I32 -> I32
|
|
fac = \n, accum ->
|
|
if n > 1 then
|
|
fac (n - 1) (n * accum)
|
|
else
|
|
accum
|
|
|
|
main : I32
|
|
main = fac 8 1
|
|
"#
|
|
),
|
|
40_320,
|
|
i32
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_add_f64() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
1.1 + 2.4 + 3
|
|
"#
|
|
),
|
|
6.5,
|
|
f64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_sub_i64() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
1 - 2 - 3
|
|
"#
|
|
),
|
|
-4,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_mul_i64() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
2 * 4 * 6
|
|
"#
|
|
),
|
|
48,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn i64_force_stack() {
|
|
// This claims 33 registers. One more than Arm and RISC-V, and many more than x86-64.
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
a = 0
|
|
b = 1
|
|
c = 2
|
|
d = 3
|
|
e = 4
|
|
f = 5
|
|
g = 6
|
|
h = 7
|
|
i = 8
|
|
j = 9
|
|
k = 10
|
|
l = 11
|
|
m = 12
|
|
n = 13
|
|
o = 14
|
|
p = 15
|
|
q = 16
|
|
r = 17
|
|
s = 18
|
|
t = 19
|
|
u = 20
|
|
v = 21
|
|
w = 22
|
|
x = 23
|
|
y = 24
|
|
z = 25
|
|
aa = 26
|
|
ab = 27
|
|
ac = 28
|
|
ad = 29
|
|
ae = 30
|
|
af = 31
|
|
ag = 32
|
|
|
|
a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p + q + r + s + t + u + v + w + x + y + z + aa + ab + ac + ad + ae + af + ag
|
|
"#
|
|
),
|
|
528,
|
|
i64
|
|
);
|
|
}
|
|
|
|
// #[test]
|
|
// fn i64_abs() {
|
|
// assert_evals_to!("Num.abs -6", 6, i64);
|
|
// assert_evals_to!("Num.abs 7", 7, i64);
|
|
// assert_evals_to!("Num.abs 0", 0, i64);
|
|
// assert_evals_to!("Num.abs -0", 0, i64);
|
|
// assert_evals_to!("Num.abs -1", 1, i64);
|
|
// assert_evals_to!("Num.abs 1", 1, i64);
|
|
// assert_evals_to!("Num.abs 9_000_000_000_000", 9_000_000_000_000, i64);
|
|
// assert_evals_to!("Num.abs -9_000_000_000_000", 9_000_000_000_000, i64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_int_eq() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// 4 == 4
|
|
// "#
|
|
// ),
|
|
// true,
|
|
// bool
|
|
// );
|
|
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// 3 == 4
|
|
// "#
|
|
// ),
|
|
// false,
|
|
// bool
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_basic_fn() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// always42 : Num.Num (Num.Integer Num.Signed64) -> Num.Num (Num.Integer Num.Signed64)
|
|
// always42 = \_ -> 42
|
|
|
|
// always42 5
|
|
// "#
|
|
// ),
|
|
// 42,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_wrap_add_nums() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// add2 = \num1, num2 -> num1 + num2
|
|
|
|
// add2 4 5
|
|
// "#
|
|
// ),
|
|
// 9,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_wrap_add_nums_force_stack() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// add9 = \num1, num2, num3, num4, num5, num6, num7, num8, num9 -> num1 + num2 + num3 + num4 + num5 + num6 + num7 + num8 + num9
|
|
|
|
// add9 1 2 3 4 5 6 7 8 9
|
|
// "#
|
|
// ),
|
|
// 45,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn pow_int() {
|
|
// assert_evals_to!("Num.powInt 2 3", 8, i64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn acos() {
|
|
// assert_evals_to!("Num.acos 0.5", 1.0471975511965979, f64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn asin() {
|
|
// assert_evals_to!("Num.asin 0.5", 0.5235987755982989, f64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn atan() {
|
|
// assert_evals_to!("Num.atan 10", 1.4711276743037347, f64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_if_fn() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// limitedNegate = \num ->
|
|
// x =
|
|
// if num == 1 then
|
|
// -1
|
|
// else if num == -1 then
|
|
// 1
|
|
// else
|
|
// num
|
|
// x
|
|
|
|
// limitedNegate 1
|
|
// "#
|
|
// ),
|
|
// -1,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_fib_fn() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// fib = \n ->
|
|
// if n == 0 then
|
|
// 0
|
|
// else if n == 1 then
|
|
// 1
|
|
// else
|
|
// (fib (n - 1)) + (fib (n - 2))
|
|
|
|
// fib 10
|
|
// "#
|
|
// ),
|
|
// 55,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn f64_abs() {
|
|
// assert_evals_to!("Num.abs -4.7", 4.7, f64);
|
|
// assert_evals_to!("Num.abs 5.8", 5.8, f64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn f64_round() {
|
|
// assert_evals_to!("Num.round 3.6", 4, i64);
|
|
// assert_evals_to!("Num.round 3.4", 3, i64);
|
|
// assert_evals_to!("Num.round 2.5", 3, i64);
|
|
// assert_evals_to!("Num.round -2.3", -2, i64);
|
|
// assert_evals_to!("Num.round -2.5", -3, i64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn f64_sqrt() {
|
|
// // FIXME this works with normal types, but fails when checking uniqueness types
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// when Num.sqrt 100 is
|
|
// Ok val -> val
|
|
// Err _ -> -1
|
|
// "#
|
|
// ),
|
|
// 10.0,
|
|
// f64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_float_eq() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// 1.0 == 1.0
|
|
// "#
|
|
// ),
|
|
// true,
|
|
// bool
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_div_f64() {
|
|
// // FIXME this works with normal types, but fails when checking uniqueness types
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// when 48 / 2 is
|
|
// Ok val -> val
|
|
// Err _ -> -1
|
|
// "#
|
|
// ),
|
|
// 24.0,
|
|
// f64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_int_neq() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// 4 != 5
|
|
// "#
|
|
// ),
|
|
// true,
|
|
// bool
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_wrap_int_neq() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// wrappedNotEq : a, a -> Bool
|
|
// wrappedNotEq = \num1, num2 ->
|
|
// num1 != num2
|
|
|
|
// wrappedNotEq 2 3
|
|
// "#
|
|
// ),
|
|
// true,
|
|
// bool
|
|
// );
|
|
// }
|
|
|
|
#[test]
|
|
fn gen_sub_f64() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
1.5 - 2.4 - 3
|
|
"#
|
|
),
|
|
-3.9,
|
|
f64
|
|
);
|
|
}
|
|
|
|
// #[test]
|
|
// fn gen_div_i64() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// when 1000 // 10 is
|
|
// Ok val -> val
|
|
// Err _ -> -1
|
|
// "#
|
|
// ),
|
|
// 100,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_div_by_zero_i64() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// when 1000 // 0 is
|
|
// Err DivByZero -> 99
|
|
// _ -> -24
|
|
// "#
|
|
// ),
|
|
// 99,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_rem_i64() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// when Num.rem 8 3 is
|
|
// Ok val -> val
|
|
// Err _ -> -1
|
|
// "#
|
|
// ),
|
|
// 2,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_rem_div_by_zero_i64() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// when Num.rem 8 0 is
|
|
// Err DivByZero -> 4
|
|
// Ok _ -> -23
|
|
// "#
|
|
// ),
|
|
// 4,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_is_zero_i64() {
|
|
// assert_evals_to!("Num.isZero 0", true, bool);
|
|
// assert_evals_to!("Num.isZero 1", false, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_is_positive_i64() {
|
|
// assert_evals_to!("Num.isPositive 0", false, bool);
|
|
// assert_evals_to!("Num.isPositive 1", true, bool);
|
|
// assert_evals_to!("Num.isPositive -5", false, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_is_negative_i64() {
|
|
// assert_evals_to!("Num.isNegative 0", false, bool);
|
|
// assert_evals_to!("Num.isNegative 3", false, bool);
|
|
// assert_evals_to!("Num.isNegative -2", true, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_is_positive_f64() {
|
|
// assert_evals_to!("Num.isPositive 0.0", false, bool);
|
|
// assert_evals_to!("Num.isPositive 4.7", true, bool);
|
|
// assert_evals_to!("Num.isPositive -8.5", false, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_is_negative_f64() {
|
|
// assert_evals_to!("Num.isNegative 0.0", false, bool);
|
|
// assert_evals_to!("Num.isNegative 9.9", false, bool);
|
|
// assert_evals_to!("Num.isNegative -4.4", true, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_is_zero_f64() {
|
|
// assert_evals_to!("Num.isZero 0", true, bool);
|
|
// assert_evals_to!("Num.isZero 0_0", true, bool);
|
|
// assert_evals_to!("Num.isZero 0.0", true, bool);
|
|
// assert_evals_to!("Num.isZero 1", false, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_is_odd() {
|
|
// assert_evals_to!("Num.isOdd 4", false, bool);
|
|
// assert_evals_to!("Num.isOdd 5", true, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_is_even() {
|
|
// assert_evals_to!("Num.isEven 6", true, bool);
|
|
// assert_evals_to!("Num.isEven 7", false, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn sin() {
|
|
// assert_evals_to!("Num.sin 0", 0.0, f64);
|
|
// assert_evals_to!("Num.sin 1.41421356237", 0.9877659459922529, f64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn cos() {
|
|
// assert_evals_to!("Num.cos 0", 1.0, f64);
|
|
// assert_evals_to!("Num.cos 3.14159265359", -1.0, f64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn tan() {
|
|
// assert_evals_to!("Num.tan 0", 0.0, f64);
|
|
// assert_evals_to!("Num.tan 1", 1.557407724654902, f64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn lt_i64() {
|
|
// assert_evals_to!("1 < 2", true, bool);
|
|
// assert_evals_to!("1 < 1", false, bool);
|
|
// assert_evals_to!("2 < 1", false, bool);
|
|
// assert_evals_to!("0 < 0", false, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn lte_i64() {
|
|
// assert_evals_to!("1 <= 1", true, bool);
|
|
// assert_evals_to!("2 <= 1", false, bool);
|
|
// assert_evals_to!("1 <= 2", true, bool);
|
|
// assert_evals_to!("0 <= 0", true, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gt_i64() {
|
|
// assert_evals_to!("2 > 1", true, bool);
|
|
// assert_evals_to!("2 > 2", false, bool);
|
|
// assert_evals_to!("1 > 1", false, bool);
|
|
// assert_evals_to!("0 > 0", false, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gte_i64() {
|
|
// assert_evals_to!("1 >= 1", true, bool);
|
|
// assert_evals_to!("1 >= 2", false, bool);
|
|
// assert_evals_to!("2 >= 1", true, bool);
|
|
// assert_evals_to!("0 >= 0", true, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn lt_f64() {
|
|
// assert_evals_to!("1.1 < 1.2", true, bool);
|
|
// assert_evals_to!("1.1 < 1.1", false, bool);
|
|
// assert_evals_to!("1.2 < 1.1", false, bool);
|
|
// assert_evals_to!("0.0 < 0.0", false, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn lte_f64() {
|
|
// assert_evals_to!("1.1 <= 1.1", true, bool);
|
|
// assert_evals_to!("1.2 <= 1.1", false, bool);
|
|
// assert_evals_to!("1.1 <= 1.2", true, bool);
|
|
// assert_evals_to!("0.0 <= 0.0", true, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gt_f64() {
|
|
// assert_evals_to!("2.2 > 1.1", true, bool);
|
|
// assert_evals_to!("2.2 > 2.2", false, bool);
|
|
// assert_evals_to!("1.1 > 2.2", false, bool);
|
|
// assert_evals_to!("0.0 > 0.0", false, bool);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gte_f64() {
|
|
// assert_evals_to!("1.1 >= 1.1", true, bool);
|
|
// assert_evals_to!("1.1 >= 1.2", false, bool);
|
|
// assert_evals_to!("1.2 >= 1.1", true, bool);
|
|
// assert_evals_to!("0.0 >= 0.0", true, bool);
|
|
// }
|
|
|
|
#[test]
|
|
fn gen_order_of_arithmetic_ops() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
1 + 3 * 7 - 2
|
|
"#
|
|
),
|
|
20,
|
|
i64
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn gen_order_of_arithmetic_ops_complex_float() {
|
|
assert_evals_to!(
|
|
indoc!(
|
|
r#"
|
|
3 - 48 * 2.0
|
|
"#
|
|
),
|
|
-93.0,
|
|
f64
|
|
);
|
|
}
|
|
|
|
// #[test]
|
|
// fn if_guard_bind_variable_false() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// wrapper = \{} ->
|
|
// when 10 is
|
|
// x if x == 5 -> 0
|
|
// _ -> 42
|
|
|
|
// wrapper {}
|
|
// "#
|
|
// ),
|
|
// 42,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn if_guard_bind_variable_true() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// wrapper = \{} ->
|
|
// when 10 is
|
|
// x if x == 10 -> 42
|
|
// _ -> 0
|
|
|
|
// wrapper {}
|
|
// "#
|
|
// ),
|
|
// 42,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn tail_call_elimination() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// sum = \n, accum ->
|
|
// when n is
|
|
// 0 -> accum
|
|
// _ -> sum (n - 1) (n + accum)
|
|
|
|
// sum 1_000_000 0
|
|
// "#
|
|
// ),
|
|
// 500000500000,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn int_negate() {
|
|
// assert_evals_to!("Num.neg 123", -123, i64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn gen_wrap_int_neg() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// wrappedNeg = \num -> -num
|
|
|
|
// wrappedNeg 3
|
|
// "#
|
|
// ),
|
|
// -3,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn int_to_float() {
|
|
// assert_evals_to!("Num.toFloat 0x9", 9.0, f64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn num_to_float() {
|
|
// assert_evals_to!("Num.toFloat 9", 9.0, f64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn float_to_float() {
|
|
// assert_evals_to!("Num.toFloat 0.5", 0.5, f64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn int_compare() {
|
|
// assert_evals_to!("Num.compare 0 1", RocOrder::Lt, RocOrder);
|
|
// assert_evals_to!("Num.compare 1 1", RocOrder::Eq, RocOrder);
|
|
// assert_evals_to!("Num.compare 1 0", RocOrder::Gt, RocOrder);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn float_compare() {
|
|
// assert_evals_to!("Num.compare 0.01 3.14", RocOrder::Lt, RocOrder);
|
|
// assert_evals_to!("Num.compare 3.14 3.14", RocOrder::Eq, RocOrder);
|
|
// assert_evals_to!("Num.compare 3.14 0.01", RocOrder::Gt, RocOrder);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn pow() {
|
|
// assert_evals_to!("Num.pow 2.0 2.0", 4.0, f64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn ceiling() {
|
|
// assert_evals_to!("Num.ceiling 1.1", 2, i64);
|
|
// }
|
|
|
|
// #[test]
|
|
// fn floor() {
|
|
// assert_evals_to!("Num.floor 1.9", 1, i64);
|
|
// }
|
|
|
|
// // #[test]
|
|
// // #[should_panic(expected = r#"Roc failed with message: "integer addition overflowed!"#)]
|
|
// // fn int_overflow() {
|
|
// // assert_evals_to!(
|
|
// // indoc!(
|
|
// // r#"
|
|
// // 9_223_372_036_854_775_807 + 1
|
|
// // "#
|
|
// // ),
|
|
// // 0,
|
|
// // i64
|
|
// // );
|
|
// // }
|
|
|
|
// #[test]
|
|
// fn int_add_checked() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// when Num.addChecked 1 2 is
|
|
// Ok v -> v
|
|
// _ -> -1
|
|
// "#
|
|
// ),
|
|
// 3,
|
|
// i64
|
|
// );
|
|
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// when Num.addChecked 9_223_372_036_854_775_807 1 is
|
|
// Err Overflow -> -1
|
|
// Ok v -> v
|
|
// "#
|
|
// ),
|
|
// -1,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn int_add_wrap() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// Num.addWrap 9_223_372_036_854_775_807 1
|
|
// "#
|
|
// ),
|
|
// std::i64::MIN,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn float_add_checked_pass() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// when Num.addChecked 1.0 0.0 is
|
|
// Ok v -> v
|
|
// Err Overflow -> -1.0
|
|
// "#
|
|
// ),
|
|
// 1.0,
|
|
// f64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn float_add_checked_fail() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// when Num.addChecked 1.7976931348623157e308 1.7976931348623157e308 is
|
|
// Err Overflow -> -1
|
|
// Ok v -> v
|
|
// "#
|
|
// ),
|
|
// -1.0,
|
|
// f64
|
|
// );
|
|
// }
|
|
|
|
// // #[test]
|
|
// // #[should_panic(expected = r#"Roc failed with message: "float addition overflowed!"#)]
|
|
// // fn float_overflow() {
|
|
// // assert_evals_to!(
|
|
// // indoc!(
|
|
// // r#"
|
|
// // 1.7976931348623157e308 + 1.7976931348623157e308
|
|
// // "#
|
|
// // ),
|
|
// // 0.0,
|
|
// // f64
|
|
// // );
|
|
// // }
|
|
|
|
// #[test]
|
|
// fn max_i128() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// Num.maxI128
|
|
// "#
|
|
// ),
|
|
// i128::MAX,
|
|
// i128
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn num_max_int() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// Num.maxInt
|
|
// "#
|
|
// ),
|
|
// i64::MAX,
|
|
// i64
|
|
// );
|
|
// }
|
|
|
|
// #[test]
|
|
// fn num_min_int() {
|
|
// assert_evals_to!(
|
|
// indoc!(
|
|
// r#"
|
|
// Num.minInt
|
|
// "#
|
|
// ),
|
|
// i64::MIN,
|
|
// i64
|
|
// );
|
|
// }
|
|
}
|