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

// Windjammer Testing Framework
// Standard library for writing tests in pure Windjammer

// Assertion functions

/// Assert that a condition is true
pub fn assert(condition: bool) {
    if !condition {
        panic("Assertion failed: condition is false")
    }
}

/// Assert that a condition is true with a custom message
pub fn assert_msg(condition: bool, message: string) {
    if !condition {
        panic("Assertion failed: " + message)
    }
}

/// Assert that two values are equal
pub fn assert_eq<T>(actual: T, expected: T) {
    if actual != expected {
        panic("Assertion failed: expected " + format!("{}", expected) + ", got " + format!("{}", actual))
    }
}

/// Assert that two values are not equal
pub fn assert_ne<T>(actual: T, expected: T) {
    if actual == expected {
        panic("Assertion failed: values should not be equal: " + format!("{}", actual))
    }
}

/// Assert that actual > expected
pub fn assert_gt<T>(actual: T, expected: T) {
    if actual <= expected {
        panic("Assertion failed: " + format!("{}", actual) + " is not greater than " + format!("{}", expected))
    }
}

/// Assert that actual < expected
pub fn assert_lt<T>(actual: T, expected: T) {
    if actual >= expected {
        panic("Assertion failed: " + format!("{}", actual) + " is not less than " + format!("{}", expected))
    }
}

/// Assert that actual >= expected
pub fn assert_gte<T>(actual: T, expected: T) {
    if actual < expected {
        panic("Assertion failed: " + format!("{}", actual) + " is not greater than or equal to " + format!("{}", expected))
    }
}

/// Assert that actual <= expected
pub fn assert_lte<T>(actual: T, expected: T) {
    if actual > expected {
        panic("Assertion failed: " + format!("{}", actual) + " is not less than or equal to " + format!("{}", expected))
    }
}

/// Assert that a string contains a substring
pub fn assert_contains(string: string, substring: string) {
    if !string.contains(substring) {
        panic("Assertion failed: \"" + string + "\" does not contain \"" + substring + "\"")
    }
}

/// Assert that a string starts with a prefix
pub fn assert_starts_with(string: string, prefix: string) {
    if !string.starts_with(prefix) {
        panic("Assertion failed: \"" + string + "\" does not start with \"" + prefix + "\"")
    }
}

/// Assert that a string ends with a suffix
pub fn assert_ends_with(string: string, suffix: string) {
    if !string.ends_with(suffix) {
        panic("Assertion failed: \"" + string + "\" does not end with \"" + suffix + "\"")
    }
}

/// Assert that a collection is empty
pub fn assert_empty<T>(collection: Vec<T>) {
    if collection.len() > 0 {
        panic("Assertion failed: collection is not empty (length: " + format!("{}", collection.len()) + ")")
    }
}

/// Assert that a collection is not empty
pub fn assert_not_empty<T>(collection: Vec<T>) {
    if collection.len() == 0 {
        panic("Assertion failed: collection is empty")
    }
}

/// Assert that a collection has a specific length
pub fn assert_length<T>(collection: Vec<T>, expected: int) {
    if collection.len() != expected {
        panic("Assertion failed: expected length " + format!("{}", expected) + ", got " + format!("{}", collection.len()))
    }
}