windjammer 0.48.0

A simple language inspired by Go, Ruby, and Elixir that transpiles to Rust - 80% of Rust's power with 20% of the complexity
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
124
125
126
127
128
129
130
131
132

#![cfg(any(
    not(any(
        feature = "parser_tests",
        feature = "analyzer_tests",
        feature = "codegen_tests",
        feature = "interpreter_tests",
        feature = "conformance_tests",
        feature = "integration_tests",
    )),
    feature = "parser_tests",
))]

use std::env;
/// TDD Test: @test_cases Decorator Parsing
///
/// THE WINDJAMMER WAY: Test decorators with array syntax should parse correctly
///
/// This test reproduces the "Expected pattern, got Assign" parser error
/// that occurs when parsing @test_cases decorator with array arguments
use std::fs;
use std::path::PathBuf;

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_test_cases_decorator_parses() {
    // Create a minimal test file with @test_cases decorator
    let _tmp = tempfile::tempdir().unwrap();
    let test_dir = _tmp.path().join(format!(
        "wj_test_cases_{}_{}",
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos(),
        std::process::id()
    ));

    fs::create_dir_all(&test_dir).unwrap();

    // Test file with @test_cases decorator
    let test_content = r#"
use windjammer_runtime::test::*

@test_cases([
    [5, 5],
    [10, 10]
])
fn test_capacity(capacity: i32, expected: i32) {
    assert_eq!(capacity, expected, "Should match")
}
"#;

    fs::write(test_dir.join("test_cases.wj"), test_content).unwrap();

    // Try to parse the file
    let wj_binary = PathBuf::from(env!("CARGO_BIN_EXE_wj"));
    let output = std::process::Command::new(&wj_binary)
        .arg("build")
        .arg("--no-cargo")
        .arg(test_dir.join("test_cases.wj"))
        .output()
        .expect("Failed to run wj build");

    // Cleanup

    // Assert no "Expected pattern, got Assign" error
    let stderr = String::from_utf8_lossy(&output.stderr);
    let stdout = String::from_utf8_lossy(&output.stdout);

    if stderr.contains("Expected pattern, got Assign")
        || stdout.contains("Expected pattern, got Assign")
    {
        panic!(
            "Parser error 'Expected pattern, got Assign' occurred:\nSTDOUT:\n{}\nSTDERR:\n{}",
            stdout, stderr
        );
    }

    // Should compile successfully (or at least not have parser errors)
    // Note: May fail with other errors (missing dependencies, etc.) but not parser errors
}

#[test]
#[cfg_attr(tarpaulin, ignore)]
fn test_simple_test_decorator_works() {
    // Create a minimal test file with @test decorator (should work)
    let _tmp2 = tempfile::tempdir().unwrap();
    let test_dir = _tmp2.path().join(format!(
        "wj_simple_test_{}_{}",
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos(),
        std::process::id()
    ));

    fs::create_dir_all(&test_dir).unwrap();

    // Simple test file with @test decorator
    let test_content = r#"
use windjammer_runtime::test::*

@test
fn test_basic() {
    let x = 1 + 1
    assert_eq!(x, 2, "Math works")
}
"#;

    fs::write(test_dir.join("simple_test.wj"), test_content).unwrap();

    // Try to parse the file
    let wj_binary = PathBuf::from(env!("CARGO_BIN_EXE_wj"));
    let output = std::process::Command::new(&wj_binary)
        .arg("build")
        .arg("--no-cargo")
        .arg(test_dir.join("simple_test.wj"))
        .output()
        .expect("Failed to run wj build");

    // Cleanup

    // Assert no parser errors
    let stderr = String::from_utf8_lossy(&output.stderr);
    let stdout = String::from_utf8_lossy(&output.stdout);

    assert!(
        !stderr.contains("Expected pattern") && !stdout.contains("Expected pattern"),
        "Should not have parser errors for simple @test decorator:\nSTDOUT:\n{}\nSTDERR:\n{}",
        stdout,
        stderr
    );
}