mirror of
https://github.com/nushell/nushell.git
synced 2024-11-28 19:33:47 +01:00
a2873336bb
Recommend holding until after #13125 is fully digested and *possibly* until 0.96. # Description Fixes one of the issues described in #13125 The `do` signature included a `SyntaxShape:Any` as one of the possible first-positional types. This is incorrect. `do` only takes a closure as a positional. This had the result of: 1. Moving what should have been a parser error to evaluation-time ## Before ```nu > do 1 Error: nu:🐚:cant_convert × Can't convert to Closure. ╭─[entry #26:1:4] 1 │ do 1 · ┬ · ╰── can't convert int to Closure ╰──── ``` ## After ```nu > do 1 Error: nu::parser::parse_mismatch × Parse mismatch during operation. ╭─[entry #5:1:4] 1 │ do 1 · ┬ · ╰── expected block, closure or record ╰──── ``` 2. Masking a bad test in `std assert` This is a bit convoluted, but `std assert` tests included testing `assert error` to make sure it: * Asserts on bad code * Doesn't assert on good code The good-code test was broken, and was essentially bad-code (really bad-code) that wasn't getting caught due to the bad signature. Fixing this resulted in *parse time* failures on every call to `test_asserts` (not something that particular test was designed to handle. This PR also fixes the test case to properly evaluate `std assert error` against a good code path. # User-Facing Changes * Error-type returned (possible breaking change?) # Tests + Formatting - 🟢 `toolkit fmt` - 🟢 `toolkit clippy` - 🟢 `toolkit test` - 🟢 `toolkit test stdlib` # After Submitting N/A
81 lines
1.7 KiB
Plaintext
81 lines
1.7 KiB
Plaintext
use std *
|
|
|
|
#[test]
|
|
def assert_basic [] {
|
|
assert true
|
|
assert (1 + 2 == 3)
|
|
assert error { assert false }
|
|
assert error { assert (1 + 2 == 4) }
|
|
}
|
|
|
|
#[test]
|
|
def assert_not [] {
|
|
assert not false
|
|
assert not (1 + 2 == 4)
|
|
assert error { assert not true }
|
|
assert error { assert not (1 + 2 == 3) }
|
|
}
|
|
|
|
#[test]
|
|
def assert_equal [] {
|
|
assert equal (1 + 2) 3
|
|
assert equal (0.1 + 0.2 | into string | into float) 0.3 # 0.30000000000000004 == 0.3
|
|
assert error { assert equal 1 "foo" }
|
|
assert error { assert equal (1 + 2) 4 }
|
|
}
|
|
|
|
#[test]
|
|
def assert_not_equal [] {
|
|
assert not equal (1 + 2) 4
|
|
assert not equal 1 "foo"
|
|
assert not equal (1 + 2) "3"
|
|
assert error { assert not equal 1 1 }
|
|
}
|
|
|
|
#[test]
|
|
def assert_error [] {
|
|
let failing_code = {|| missing_code_to_run}
|
|
assert error $failing_code
|
|
|
|
let good_code = {|| }
|
|
let assert_error_raised = (try { assert error $good_code; false } catch { true })
|
|
assert $assert_error_raised "The assert error should be false if there is no error in the executed code."
|
|
}
|
|
|
|
#[test]
|
|
def assert_less [] {
|
|
assert less 1 2
|
|
assert error { assert less 1 1 }
|
|
}
|
|
|
|
#[test]
|
|
def assert_less_or_equal [] {
|
|
assert less or equal 1 2
|
|
assert less or equal 1 1
|
|
assert error { assert less or equal 1 0 }
|
|
}
|
|
|
|
#[test]
|
|
def assert_greater [] {
|
|
assert greater 2 1
|
|
assert error { assert greater 2 2 }
|
|
}
|
|
|
|
#[test]
|
|
def assert_greater_or_equal [] {
|
|
assert greater or equal 1 1
|
|
assert greater or equal 2 1
|
|
assert error { assert greater or equal 0 1 }
|
|
}
|
|
|
|
#[test]
|
|
def assert_length [] {
|
|
assert length [0, 0, 0] 3
|
|
assert error { assert length [0, 0] 3 }
|
|
}
|
|
|
|
#[ignore]
|
|
def assert_skip [] {
|
|
assert true # This test case is skipped on purpose
|
|
}
|