nu 0.112.2

A new type of shell
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use crate::repl::tests::{TestResult, fail_test, run_test};
use rstest::rstest;

#[test]
fn int_in_inc_range() -> TestResult {
    run_test("1 in -4..9.42", "true")
}

#[test]
fn int_in_dec_range() -> TestResult {
    run_test("1 in 9..-4.42", "true")
}

#[test]
fn int_in_exclusive_range() -> TestResult {
    run_test("3 in 0..<3", "false")
}

#[test]
fn float_in_inc_range() -> TestResult {
    run_test("1.58 in -4.42..9", "true")
}

#[test]
fn float_in_dec_range() -> TestResult {
    run_test("1.42 in 9.42..-4.42", "true")
}

#[test]
fn non_number_in_range() -> TestResult {
    fail_test("'a' in 1..3", "nu::parser::operator_incompatible_types")
}

#[test]
fn float_not_in_inc_range() -> TestResult {
    run_test("1.4 not-in 2..9.42", "true")
}

#[test]
fn range_and_reduction() -> TestResult {
    run_test("1..6..36 | math sum", "148")
}

#[test]
fn zip_ranges() -> TestResult {
    run_test("1..3 | zip 4..6 | get 2.1", "6")
}

#[test]
fn int_in_stepped_range() -> TestResult {
    run_test("7 in 1..3..15", "true")?;
    run_test("7 in 1..3..=15", "true")
}

#[test]
fn int_in_unbounded_stepped_range() -> TestResult {
    run_test("1000001 in 1..3..", "true")
}

#[test]
fn int_not_in_unbounded_stepped_range() -> TestResult {
    run_test("2 in 1..3..", "false")
}

#[test]
fn float_in_stepped_range() -> TestResult {
    run_test("5.5 in 1..1.5..10", "true")
}

#[test]
fn float_in_unbounded_stepped_range() -> TestResult {
    run_test("100.5 in 1..1.5..", "true")
}

#[test]
fn float_not_in_unbounded_stepped_range() -> TestResult {
    run_test("2.1 in 1.2..3..", "false")
}

#[rstest]
#[case("1..=3..", "expected number")]
#[case("..=3..=15", "expected number")]
#[case("..=(..", "expected closing )")]
#[case("..=()..", "expected at least one range bound")]
#[case("..=..", "expected at least one range bound")]
#[test]
fn bad_range_syntax(#[case] input: &str, #[case] expect: &str) -> TestResult {
    fail_test(&format!("def foo [r: range] {{}}; foo {input}"), expect)
}