async-rev-buf 0.1.0

High-performance async buffered reader for reading lines in reverse order from files and streams
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
130
131
132
133
134
135
136
137
138
139
140
141
142

//! Basic integration tests for async_rev_buf crate

use async_rev_buf::RevBufReader;
use std::io::Write;
use tempfile::NamedTempFile;
use tokio::fs::File;

#[tokio::test]
async fn test_basic_reverse_reading() {
    // Create a temporary file with test content
    let mut temp_file = NamedTempFile::new().unwrap();
    let content = "first line\nsecond line\nthird line\nfourth line";
    temp_file.write_all(content.as_bytes()).unwrap();
    temp_file.flush().unwrap();

    // Read lines in reverse
    let file = File::open(temp_file.path()).await.unwrap();
    let reader = RevBufReader::new(file);
    let mut lines = reader.lines();

    let mut result = Vec::new();
    while let Some(line) = lines.next_line().await.unwrap() {
        result.push(line);
    }

    assert_eq!(
        result,
        vec!["fourth line", "third line", "second line", "first line"]
    );
}

#[tokio::test]
async fn test_empty_file() {
    let mut temp_file = NamedTempFile::new().unwrap();
    temp_file.flush().unwrap();

    let file = File::open(temp_file.path()).await.unwrap();
    let reader = RevBufReader::new(file);
    let mut lines = reader.lines();

    let line = lines.next_line().await.unwrap();
    assert!(line.is_none());
}

#[tokio::test]
async fn test_single_line() {
    let mut temp_file = NamedTempFile::new().unwrap();
    temp_file.write_all(b"only line").unwrap();
    temp_file.flush().unwrap();

    let file = File::open(temp_file.path()).await.unwrap();
    let reader = RevBufReader::new(file);
    let mut lines = reader.lines();

    let line1 = lines.next_line().await.unwrap();
    assert_eq!(line1, Some("only line".to_string()));

    let line2 = lines.next_line().await.unwrap();
    assert!(line2.is_none());
}

#[tokio::test]
async fn test_custom_buffer_size() {
    let mut temp_file = NamedTempFile::new().unwrap();
    temp_file.write_all(b"line1\nline2\nline3").unwrap();
    temp_file.flush().unwrap();

    let file = File::open(temp_file.path()).await.unwrap();
    let reader = RevBufReader::with_capacity(8, file); // Small buffer
    let mut lines = reader.lines();

    let mut result = Vec::new();
    while let Some(line) = lines.next_line().await.unwrap() {
        result.push(line);
    }

    assert_eq!(result, vec!["line3", "line2", "line1"]);
}

#[tokio::test]
async fn test_unicode_content() {
    let mut temp_file = NamedTempFile::new().unwrap();
    let content = "๐ŸŽ‰ first line\nํ•œ๊ตญ์–ด second line\nั€ัƒััะบะธะน third line";
    temp_file.write_all(content.as_bytes()).unwrap();
    temp_file.flush().unwrap();

    let file = File::open(temp_file.path()).await.unwrap();
    let reader = RevBufReader::new(file);
    let mut lines = reader.lines();

    let mut result = Vec::new();
    while let Some(line) = lines.next_line().await.unwrap() {
        result.push(line);
    }

    assert_eq!(
        result,
        vec!["ั€ัƒััะบะธะน third line", "ํ•œ๊ตญ์–ด second line", "๐ŸŽ‰ first line"]
    );
}

#[tokio::test]
async fn test_accessor_methods() {
    let mut temp_file = NamedTempFile::new().unwrap();
    temp_file.write_all(b"test").unwrap();
    temp_file.flush().unwrap();

    let file = File::open(temp_file.path()).await.unwrap();
    let mut reader = RevBufReader::new(file);

    // Test accessor methods
    assert!(reader.get_ref().metadata().await.is_ok());
    assert!(reader.get_mut().metadata().await.is_ok());

    // Test buffer method
    assert!(reader.buffer().is_empty());

    // Test into_inner
    let _inner = reader.into_inner();
}

#[tokio::test]
async fn test_lines_methods() {
    let mut temp_file = NamedTempFile::new().unwrap();
    temp_file.write_all(b"line1\nline2").unwrap();
    temp_file.flush().unwrap();

    let file = File::open(temp_file.path()).await.unwrap();
    let reader = RevBufReader::new(file);
    let mut lines = reader.lines();

    // Test accessor methods
    let _reader_ref = lines.get_ref();
    let _reader_mut = lines.get_mut();

    // Read one line
    let line = lines.next_line().await.unwrap();
    assert_eq!(line, Some("line2".to_string()));

    // Test into_inner
    let _reader = lines.into_inner();
}