qubit-io 0.7.0

Byte-stream buffering and std::io utilities for 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

// =============================================================================
//    Copyright (c) 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================

use qubit_io::Buffer;

#[test]
fn test_with_capacity_initializes_empty_window() {
    let buffer = Buffer::<u8>::with_capacity(4);

    assert_eq!(4, buffer.capacity());
    assert_eq!(0, buffer.position());
    assert_eq!(0, buffer.limit());
    assert_eq!(0, buffer.available());
    assert_eq!(4, buffer.spare_capacity());
    assert!(buffer.is_empty());
    assert!(!buffer.is_full());
}

#[test]
fn test_copy_from_unchecked_appends_to_spare_window() {
    let mut buffer = Buffer::<u8>::with_capacity(6);
    let input = b"abcdef";

    // SAFETY: `input[1..4]` is valid and the empty buffer has enough spare
    // capacity for three bytes.
    unsafe {
        buffer.copy_from_unchecked(input, 1, 3);
    }

    assert_eq!(0, buffer.position());
    assert_eq!(3, buffer.limit());
    assert_eq!(3, buffer.available());
    assert_eq!(b"bcd", &buffer.data()[0..3]);
}

#[test]
fn test_advance_marks_spare_values_as_readable() {
    let mut buffer = Buffer::<u8>::with_capacity(4);

    buffer.data_mut()[0..2].copy_from_slice(b"ab");
    buffer.advance(2);

    assert_eq!(0, buffer.position());
    assert_eq!(2, buffer.limit());
    assert_eq!(2, buffer.available());
    assert_eq!(2, buffer.spare_capacity());
    assert_eq!(b"ab", &buffer.data()[0..2]);
}

#[test]
fn test_copy_to_unchecked_consumes_from_readable_window() {
    let mut buffer = Buffer::<u8>::with_capacity(6);
    let input = b"abcdef";
    let mut output = [0_u8; 5];

    // SAFETY: The input range and spare range are valid for six bytes.
    unsafe {
        buffer.copy_from_unchecked(input, 0, 6);
    }
    buffer.consume(2);
    // SAFETY: Three bytes are available and `output[1..4]` is valid.
    unsafe {
        buffer.copy_to_unchecked(&mut output, 1, 3);
    }

    assert_eq!([0, b'c', b'd', b'e', 0], output);
    assert_eq!(5, buffer.position());
    assert_eq!(6, buffer.limit());
    assert_eq!(1, buffer.available());
}

#[test]
fn test_compact_moves_unread_tail_to_front() {
    let mut buffer = Buffer::<u8>::with_capacity(6);

    // SAFETY: The input range and spare range are valid for five bytes.
    unsafe {
        buffer.copy_from_unchecked(b"abcde", 0, 5);
    }
    buffer.consume(2);
    buffer.compact();

    assert_eq!(0, buffer.position());
    assert_eq!(3, buffer.limit());
    assert_eq!(3, buffer.available());
    assert_eq!(3, buffer.spare_capacity());
    assert_eq!(b"cde", &buffer.data()[0..3]);
}

#[test]
fn test_compact_clears_empty_readable_window() {
    let mut buffer = Buffer::<u8>::with_capacity(4);

    buffer.advance(3);
    buffer.consume(3);
    buffer.compact();

    assert_eq!(0, buffer.position());
    assert_eq!(0, buffer.limit());
    assert_eq!(0, buffer.available());
    assert_eq!(4, buffer.spare_capacity());
    assert!(buffer.is_empty());
}