sux 0.14.0

A pure Rust implementation of succinct and compressed data structures
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
129

/*
 * SPDX-FileCopyrightText: 2023 Inria
 * SPDX-FileCopyrightText: 2023 Sebastiano Vigna
 *
 * SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
 */

use sux::prelude::*;
use sux::traits::{IndexedSeq, IntoIteratorFrom};

#[test]
fn test_slice_seq_new() {
    let data = vec![1usize, 2, 3, 4, 5];
    let seq = SliceSeq::new(&data);
    assert_eq!(seq.len(), 5);
}

#[test]
fn test_slice_seq_from() {
    let data = vec![10usize, 20, 30];
    let seq: SliceSeq<usize, _> = SliceSeq::from(&data);
    assert_eq!(seq.len(), 3);
}

#[test]
fn test_slice_seq_get_unchecked() {
    let data = vec![100usize, 200, 300, 400];
    let seq = SliceSeq::new(&data);
    unsafe {
        assert_eq!(seq.get_unchecked(0), 100);
        assert_eq!(seq.get_unchecked(1), 200);
        assert_eq!(seq.get_unchecked(2), 300);
        assert_eq!(seq.get_unchecked(3), 400);
    }
}

#[test]
fn test_slice_seq_len() {
    let empty: Vec<usize> = vec![];
    let seq_empty = SliceSeq::new(&empty);
    assert_eq!(seq_empty.len(), 0);
    assert!(seq_empty.is_empty());

    let data = vec![1usize, 2, 3];
    let seq = SliceSeq::new(&data);
    assert_eq!(seq.len(), 3);
    assert!(!seq.is_empty());
}

#[test]
fn test_slice_seq_iter() {
    let data = vec![5usize, 10, 15, 20];
    let seq = SliceSeq::new(&data);
    let collected: Vec<_> = seq.iter().collect();
    assert_eq!(collected, vec![5, 10, 15, 20]);
}

#[test]
fn test_slice_seq_into_iterator() {
    let data = vec![1usize, 2, 3];
    let seq = SliceSeq::new(&data);
    let collected: Vec<_> = (&seq).into_iter().collect();
    assert_eq!(collected, vec![1, 2, 3]);
}

#[test]
fn test_slice_seq_into_iterator_from() {
    let data = vec![10usize, 20, 30, 40, 50];
    let seq = SliceSeq::new(&data);
    let collected: Vec<_> = (&seq).into_iter_from(2).collect();
    assert_eq!(collected, vec![30, 40, 50]);
}

#[test]
fn test_slice_seq_into_iterator_from_zero() {
    let data = vec![1usize, 2, 3];
    let seq = SliceSeq::new(&data);
    let collected: Vec<_> = (&seq).into_iter_from(0).collect();
    assert_eq!(collected, vec![1, 2, 3]);
}

#[test]
fn test_slice_seq_into_iterator_from_end() {
    let data = vec![1usize, 2, 3];
    let seq = SliceSeq::new(&data);
    let collected: Vec<_> = (&seq).into_iter_from(3).collect();
    assert!(collected.is_empty());
}

#[test]
fn test_slice_seq_with_array() {
    let data = [1usize, 2, 3, 4];
    let seq = SliceSeq::new(&data);
    assert_eq!(seq.len(), 4);
    unsafe {
        assert_eq!(seq.get_unchecked(0), 1);
        assert_eq!(seq.get_unchecked(3), 4);
    }
}

#[test]
fn test_slice_seq_equality() {
    let data1 = vec![1usize, 2, 3];
    let data2 = vec![1usize, 2, 3];
    let data3 = vec![1usize, 2, 4];
    let seq1 = SliceSeq::new(&data1);
    let seq2 = SliceSeq::new(&data2);
    let seq3 = SliceSeq::new(&data3);
    // Equality compares the underlying slice content
    assert_eq!(seq1, seq1);
    assert_eq!(seq1, seq2); // Same contents = equal
    assert_ne!(seq1, seq3); // Different contents
}

#[test]
fn test_slice_seq_clone() {
    let data = vec![1usize, 2, 3];
    let seq = SliceSeq::new(&data);
    let cloned = seq.clone();
    assert_eq!(seq.len(), cloned.len());
}

#[test]
fn test_slice_seq_debug() {
    let data = vec![1usize, 2, 3];
    let seq = SliceSeq::new(&data);
    let debug_str = format!("{:?}", seq);
    assert!(debug_str.contains("SliceSeq"));
}