ruchy 4.1.2

A systems scripting language that transpiles to idiomatic Rust with extreme quality engineering
Documentation 
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

#![allow(missing_docs)]
//! Integration tests for enum runtime support
//!
//! Tests enum variant construction and execution:
//! - Unit variants (`Status::Success`)
//! - Tuple variants (`Response::Error("msg`"))
//! - Keyword variants (`Maybe::Some`, `Maybe::None`)

use assert_cmd::Command;
use predicates::prelude::*;

fn ruchy_cmd() -> Command {
    assert_cmd::cargo::cargo_bin_cmd!("ruchy")
}

#[test]
fn test_enum_unit_variants() {
    let code = r#"
enum Status {
    Success,
    Pending,
    Failed
}

let s1 = Status::Success
let s2 = Status::Pending
let s3 = Status::Failed
println("All unit variants work")
"#;

    ruchy_cmd()
        .arg("-e")
        .arg(code)
        .assert()
        .success()
        .stdout(predicate::str::contains("All unit variants work"));
}

#[test]
fn test_enum_tuple_variants() {
    let code = r#"
enum Response {
    Ok,
    Error(String)
}

let ok = Response::Ok
let err = Response::Error("Something went wrong")
println("Tuple variants work")
"#;

    ruchy_cmd()
        .arg("-e")
        .arg(code)
        .assert()
        .success()
        .stdout(predicate::str::contains("Tuple variants work"));
}

#[test]
fn test_enum_keyword_variants() {
    let code = r#"
enum Maybe {
    Some,
    None
}

let some = Maybe::Some
let none = Maybe::None
println("Keyword variants work")
"#;

    ruchy_cmd()
        .arg("-e")
        .arg(code)
        .assert()
        .success()
        .stdout(predicate::str::contains("Keyword variants work"));
}

#[test]
fn test_enum_multiple_tuple_variants() {
    let code = r#"
enum Message {
    Quit,
    Move(String),
    Write(String)
}

let m1 = Message::Quit
let m2 = Message::Move("up")
let m3 = Message::Write("hello")
println("Multiple tuple variants work")
"#;

    ruchy_cmd()
        .arg("-e")
        .arg(code)
        .assert()
        .success()
        .stdout(predicate::str::contains("Multiple tuple variants work"));
}

#[test]
fn test_enum_ok_err_variants() {
    let code = r#"
enum Outcome {
    Ok,
    Err
}

let success = Outcome::Ok
let failure = Outcome::Err
println("Ok and Err keyword variants work")
"#;

    ruchy_cmd()
        .arg("-e")
        .arg(code)
        .assert()
        .success()
        .stdout(predicate::str::contains("Ok and Err keyword variants work"));
}