reflow_rt_capi 0.2.1

C ABI bindings for the Reflow runtime — the shared native surface consumed by Go (cgo), Kotlin/Java (JNI), and other non-Rust callers.
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

//! Multi-graph composition smoke test for the C ABI.

use reflow_rt_capi::*;
use std::ffi::{CStr, CString};

fn cstr(s: &str) -> CString {
    CString::new(s).unwrap()
}

#[test]
fn compose_two_graphs_produces_merged_export() {
    // Two tiny graphs, each with one node referencing a different
    // component; we compose them with no cross-graph connection.
    let composition = serde_json::json!({
        "graphs": [
            {
                "caseSensitive": false,
                "processes": { "a": { "id": "a", "component": "tpl_passthrough", "metadata": null } },
                "connections": [], "inports": {}, "outports": {},
                "properties": { "name": "left" }, "groups": []
            },
            {
                "caseSensitive": false,
                "processes": { "b": { "id": "b", "component": "tpl_passthrough", "metadata": null } },
                "connections": [], "inports": {}, "outports": {},
                "properties": { "name": "right" }, "groups": []
            }
        ],
        "connections": [],
        "shared_resources": [],
        "properties": { "name": "composed" },
        "case_sensitive": false
    });

    let input = cstr(&composition.to_string());
    let out = unsafe { rfl_compose_graphs(input.as_ptr()) };

    if out.is_null() {
        let err = rfl_last_error_message();
        let msg = if err.is_null() {
            "(no error message)".into()
        } else {
            let s = unsafe { CStr::from_ptr(err).to_str().unwrap().to_owned() };
            unsafe { rfl_string_free(err) };
            s
        };
        panic!("compose returned null: {msg}");
    }

    let raw = unsafe { CStr::from_ptr(out).to_str().unwrap().to_owned() };
    unsafe { rfl_string_free(out) };

    let v: serde_json::Value = serde_json::from_str(&raw).unwrap();
    let processes = v.get("processes").unwrap().as_object().unwrap();
    // The two nodes survive the composition under namespace-prefixed keys.
    assert!(
        processes
            .keys()
            .any(|k| k.contains("a") || k.contains("left/a")),
        "missing 'a' in composed processes: {:?}",
        processes.keys().collect::<Vec<_>>()
    );
    assert!(
        processes
            .keys()
            .any(|k| k.contains("b") || k.contains("right/b")),
        "missing 'b' in composed processes: {:?}",
        processes.keys().collect::<Vec<_>>()
    );
}

#[test]
fn compose_with_cross_graph_connection() {
    let composition = serde_json::json!({
        "graphs": [
            {
                "caseSensitive": false,
                "processes": { "src": { "id": "src", "component": "tpl_passthrough", "metadata": null } },
                "connections": [],
                "inports": {}, "outports": {},
                "properties": { "name": "gsrc" }, "groups": []
            },
            {
                "caseSensitive": false,
                "processes": { "sink": { "id": "sink", "component": "tpl_passthrough", "metadata": null } },
                "connections": [],
                "inports": {}, "outports": {},
                "properties": { "name": "gsink" }, "groups": []
            }
        ],
        "connections": [
            {
                "from": { "process": "gsrc/src", "port": "out" },
                "to":   { "process": "gsink/sink", "port": "in" }
            }
        ],
        "shared_resources": [],
        "properties": { "name": "pipeline" },
        "case_sensitive": false
    });

    let input = cstr(&composition.to_string());
    let out = unsafe { rfl_compose_graphs(input.as_ptr()) };
    assert!(!out.is_null(), "compose returned null");
    let raw = unsafe { CStr::from_ptr(out).to_str().unwrap().to_owned() };
    unsafe { rfl_string_free(out) };
    let v: serde_json::Value = serde_json::from_str(&raw).unwrap();
    let conns = v.get("connections").unwrap().as_array().unwrap();
    assert!(
        !conns.is_empty(),
        "expected composed connection, got: {}",
        raw
    );
}

#[test]
fn compose_rejects_invalid_json() {
    let input = cstr("not json");
    let out = unsafe { rfl_compose_graphs(input.as_ptr()) };
    assert!(out.is_null());
    let err = rfl_last_error_message();
    assert!(!err.is_null());
    unsafe {
        let msg = CStr::from_ptr(err).to_str().unwrap().to_owned();
        rfl_string_free(err);
        assert!(msg.contains("parse"), "unexpected error: {msg}");
    }
}