koicore 0.2.3

core KoiLang module
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

#![cfg(feature = "serde")]
use koicore::command::{Command, CompositeValue, Parameter, Value};
use serde_json;

#[test]
fn test_command_serialization() {
    let cmd = Command::new(
        "character",
        vec![
            Parameter::from("Alice"),
            Parameter::from("Hello, world!"),
            Parameter::Composite(
                "action".to_string(),
                CompositeValue::Single(Value::String("walk".to_string())),
            ),
        ],
    );

    let json = serde_json::to_string(&cmd).unwrap();

    // Verify JSON structure (order of keys in params might vary if it was a map, but params is a List)
    // Parameter::Basic(Alice) -> "Alice"
    // Parameter::Basic("Hello, world!") -> "Hello, world!"
    // Parameter::Composite("action", Single("walk")) -> {"action": "walk"}
    let expected_json =
        r#"{"name":"character","params":["Alice","Hello, world!",{"action":"walk"}]}"#;
    assert_eq!(json, expected_json);

    let decoded: Command = serde_json::from_str(&json).unwrap();
    assert_eq!(cmd, decoded);
}

#[test]
fn test_complex_command_serialization() {
    let cmd = Command::new(
        "action",
        vec![
            Parameter::Composite(
                "list".to_string(),
                CompositeValue::List(vec![
                    Value::Int(1),
                    Value::Float(2.5),
                    Value::Bool(true),
                    Value::String("test".to_string()),
                ]),
            ),
            Parameter::Composite(
                "dict".to_string(),
                CompositeValue::Dict(vec![
                    ("key1".to_string(), Value::Int(10)),
                    ("key2".to_string(), Value::String("value".to_string())),
                ]),
            ),
        ],
    );

    let json = serde_json::to_string(&cmd).unwrap();
    println!("JSON: {}", json);

    // {"list": [1, 2.5, true, "test"]}
    // {"dict": {"key1": 10, "key2": "value"}}
    // Note: Dict iteration order is preserved from the Vec<(String, Value)> in serialization implementation?
    // CompositeValue::Dict stores Vec<(String, Value)>. My manual impl iterates over this Vec.
    // So order IS preserved.
    let expected_json = r#"{"name":"action","params":[{"list":[1,2.5,true,"test"]},{"dict":{"key1":10,"key2":"value"}}]}"#;
    assert_eq!(json, expected_json);

    let decoded: Command = serde_json::from_str(&json).unwrap();
    assert_eq!(cmd, decoded);
}

#[test]
fn test_text_command_serialization() {
    let cmd = Command::new_text("Hello, world!");
    let json = serde_json::to_string(&cmd).unwrap();
    assert_eq!(json, r#"{"name":"@text","params":["Hello, world!"]}"#);
    let decoded: Command = serde_json::from_str(&json).unwrap();
    assert_eq!(cmd, decoded);
}

#[test]
fn test_annotation_command_serialization() {
    let cmd = Command::new_annotation("This is an annotation");
    let json = serde_json::to_string(&cmd).unwrap();
    let decoded: Command = serde_json::from_str(&json).unwrap();
    assert_eq!(cmd, decoded);
}