velesdb-core 1.15.0

High-performance vector database engine written in Rust
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

//! Tests for Layer module.

use super::layer::{Layer, NodeId};

#[test]
fn test_layer_new_empty() {
    let layer = Layer::new(0);
    assert_eq!(layer.get_neighbors(0), Vec::<NodeId>::new());
}

#[test]
fn test_layer_new_with_capacity() {
    let layer = Layer::new(10);
    // All nodes should have empty neighbor lists
    for i in 0..10 {
        assert!(layer.get_neighbors(i).is_empty());
    }
}

#[test]
fn test_layer_set_and_get_neighbors() {
    let layer = Layer::new(5);
    let neighbors = vec![1, 2, 3];

    layer.set_neighbors(0, neighbors.clone());
    assert_eq!(layer.get_neighbors(0), neighbors);
}

#[test]
fn test_layer_get_neighbors_out_of_bounds() {
    let layer = Layer::new(5);
    // Should return empty vec for out of bounds
    assert!(layer.get_neighbors(100).is_empty());
}

#[test]
fn test_layer_set_neighbors_out_of_bounds() {
    let layer = Layer::new(5);
    // Should not panic, just no-op
    layer.set_neighbors(100, vec![1, 2, 3]);
    assert!(layer.get_neighbors(100).is_empty());
}

#[test]
fn test_layer_ensure_capacity_grows() {
    let mut layer = Layer::new(5);
    assert!(layer.get_neighbors(10).is_empty());

    layer.ensure_capacity(10);
    layer.set_neighbors(10, vec![1, 2]);
    assert_eq!(layer.get_neighbors(10), vec![1, 2]);
}

#[test]
fn test_layer_ensure_capacity_no_shrink() {
    let mut layer = Layer::new(10);
    layer.set_neighbors(5, vec![1, 2, 3]);

    // ensure_capacity with smaller value should not affect existing data
    layer.ensure_capacity(3);
    assert_eq!(layer.get_neighbors(5), vec![1, 2, 3]);
}

#[test]
fn test_layer_multiple_nodes() {
    let layer = Layer::new(3);

    layer.set_neighbors(0, vec![1, 2]);
    layer.set_neighbors(1, vec![0, 2]);
    layer.set_neighbors(2, vec![0, 1]);

    assert_eq!(layer.get_neighbors(0), vec![1, 2]);
    assert_eq!(layer.get_neighbors(1), vec![0, 2]);
    assert_eq!(layer.get_neighbors(2), vec![0, 1]);
}

#[test]
fn test_layer_overwrite_neighbors() {
    let layer = Layer::new(5);

    layer.set_neighbors(0, vec![1, 2, 3]);
    assert_eq!(layer.get_neighbors(0), vec![1, 2, 3]);

    layer.set_neighbors(0, vec![4, 5]);
    assert_eq!(layer.get_neighbors(0), vec![4, 5]);
}

#[test]
fn test_layer_empty_neighbors() {
    let layer = Layer::new(5);

    layer.set_neighbors(0, vec![1, 2, 3]);
    layer.set_neighbors(0, vec![]);

    assert!(layer.get_neighbors(0).is_empty());
}

#[test]
fn test_layer_with_neighbors_reads_slice() {
    let layer = Layer::new(4);
    layer.set_neighbors(2, vec![7, 8, 9]);

    let len = layer.with_neighbors(2, <[usize]>::len);
    assert_eq!(len, Some(3));

    let sum = layer.with_neighbors(2, |neighbors| neighbors.iter().sum::<usize>());
    assert_eq!(sum, Some(24));
}

#[test]
fn test_layer_with_neighbors_out_of_bounds_returns_none() {
    let layer = Layer::new(1);
    let result = layer.with_neighbors(99, <[usize]>::len);
    assert_eq!(result, None);
}