rayforce 0.1.0

Safe Rust bindings for RayforceDB - the ultra-fast columnar database
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

//! Tests for Dict type.

mod common;

use rayforce::{Dict, I64, RayString, RayType};
use serial_test::serial;

#[test]
#[serial]
fn test_dict_from_pairs() {
    init_runtime!();
    let dict = Dict::from_pairs([
        ("key1", I64::new(100).ptr().clone()),
        ("key2", I64::new(200).ptr().clone()),
    ])
    .unwrap();

    assert_eq!(dict.len(), 2);
}

#[test]
#[serial]
fn test_dict_empty() {
    init_runtime!();
    let dict = Dict::from_pairs(std::iter::empty::<(&str, rayforce::RayObj)>()).unwrap();
    // Empty dict was created successfully
    assert!(!dict.ptr().is_nil());
}

#[test]
#[serial]
fn test_dict_single_pair() {
    init_runtime!();
    let dict = Dict::from_pairs([("name", I64::new(42).ptr().clone())]).unwrap();
    // Verify dict was created
    assert!(!dict.ptr().is_nil());
}

#[test]
#[serial]
fn test_dict_get() {
    init_runtime!();
    let dict = Dict::from_pairs([("value", I64::new(123).ptr().clone())]).unwrap();

    let val = dict.get("value");
    assert!(val.is_some());
}

#[test]
#[serial]
fn test_dict_keys() {
    init_runtime!();
    let dict = Dict::from_pairs([
        ("a", I64::new(1).ptr().clone()),
        ("b", I64::new(2).ptr().clone()),
    ])
    .unwrap();

    let keys = dict.keys();
    // Keys should be a vector of symbols
    assert!(!keys.is_nil());
}

#[test]
#[serial]
fn test_dict_values() {
    init_runtime!();
    let dict = Dict::from_pairs([
        ("x", I64::new(10).ptr().clone()),
        ("y", I64::new(20).ptr().clone()),
    ])
    .unwrap();

    let values = dict.values();
    assert!(!values.is_nil());
}

#[test]
#[serial]
fn test_dict_mixed_types() {
    init_runtime!();
    let dict = Dict::from_pairs([
        ("name", RayString::new("Alice").ptr().clone()),
        ("age", I64::new(30).ptr().clone()),
    ])
    .unwrap();

    assert_eq!(dict.len(), 2);
}

#[test]
#[serial]
fn test_dict_display() {
    init_runtime!();
    let dict = Dict::from_pairs([("key", I64::new(1).ptr().clone())]).unwrap();

    let display = format!("{}", dict);
    assert!(!display.is_empty());
}

#[test]
#[serial]
fn test_dict_debug() {
    init_runtime!();
    let dict = Dict::from_pairs([("key", I64::new(1).ptr().clone())]).unwrap();

    let debug = format!("{:?}", dict);
    assert!(debug.contains("Dict"));
}

#[test]
#[serial]
fn test_dict_clone() {
    init_runtime!();
    let dict1 = Dict::from_pairs([("test", I64::new(42).ptr().clone())]).unwrap();

    let dict2 = dict1.clone();
    // Both should be valid
    assert!(!dict1.ptr().is_nil());
    assert!(!dict2.ptr().is_nil());
}

#[test]
#[serial]
fn test_dict_type_code() {
    init_runtime!();
    let dict = Dict::from_pairs([("key", I64::new(1).ptr().clone())]).unwrap();

    // Just verify we can get the type code
    let _code = dict.type_code();
}