seq-runtime 5.6.1

Runtime library for the Seq programming language
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

use super::*;
use crate::value::Value;
use std::ffi::CString;

#[test]
fn test_write_line() {
    unsafe {
        let stack = crate::stack::alloc_test_stack();
        let stack = push(stack, Value::String("Hello, World!".into()));
        let _stack = write_line(stack);
    }
}

#[test]
fn test_write() {
    unsafe {
        let stack = crate::stack::alloc_test_stack();
        let stack = push(stack, Value::String("no newline".into()));
        let _stack = write(stack);
    }
}

#[test]
fn test_push_string() {
    unsafe {
        let stack = crate::stack::alloc_test_stack();
        let test_str = CString::new("Test").unwrap();
        let stack = push_string(stack, test_str.as_ptr());

        let (_stack, value) = pop(stack);
        assert_eq!(value, Value::String("Test".into()));
    }
}

#[test]
fn test_empty_string() {
    unsafe {
        // Empty string should be handled correctly
        let stack = crate::stack::alloc_test_stack();
        let empty_str = CString::new("").unwrap();
        let stack = push_string(stack, empty_str.as_ptr());

        let (_stack, value) = pop(stack);
        assert_eq!(value, Value::String("".into()));

        // Write empty string should work without panic
        let stack = push(stack, Value::String("".into()));
        let _stack = write_line(stack);
    }
}

#[test]
fn test_unicode_strings() {
    unsafe {
        // Test that Unicode strings are handled correctly
        let stack = crate::stack::alloc_test_stack();
        let unicode_str = CString::new("Hello, δΈ–η•Œ! 🌍").unwrap();
        let stack = push_string(stack, unicode_str.as_ptr());

        let (_stack, value) = pop(stack);
        assert_eq!(value, Value::String("Hello, δΈ–η•Œ! 🌍".into()));
    }
}

// =========================================================================
// read_n validation tests
// =========================================================================

#[test]
fn test_read_n_valid_input() {
    assert_eq!(super::validate_read_n_count(&Value::Int(0)), Ok(0));
    assert_eq!(super::validate_read_n_count(&Value::Int(100)), Ok(100));
    assert_eq!(
        super::validate_read_n_count(&Value::Int(1024 * 1024)), // 1MB
        Ok(1024 * 1024)
    );
}

#[test]
fn test_read_n_negative_input() {
    let result = super::validate_read_n_count(&Value::Int(-1));
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("must be non-negative"));
}

#[test]
fn test_read_n_large_negative_input() {
    let result = super::validate_read_n_count(&Value::Int(i64::MIN));
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("must be non-negative"));
}

#[test]
fn test_read_n_exceeds_max_bytes() {
    let result = super::validate_read_n_count(&Value::Int(super::READ_N_MAX_BYTES + 1));
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("exceeds maximum allowed"));
}

#[test]
fn test_read_n_at_max_bytes_ok() {
    // Exactly at the limit should be OK
    let result = super::validate_read_n_count(&Value::Int(super::READ_N_MAX_BYTES));
    assert_eq!(result, Ok(super::READ_N_MAX_BYTES as usize));
}

#[test]
fn test_read_n_wrong_type_string() {
    let result = super::validate_read_n_count(&Value::String("not an int".into()));
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("expected Int"));
}

#[test]
fn test_read_n_wrong_type_bool() {
    let result = super::validate_read_n_count(&Value::Bool(true));
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("expected Int"));
}