1 #[cfg(feature = "fs")]
2 #[cfg(any(target_os = "android", target_os = "linux"))]
3 #[test]
test_splice_cursor()4 fn test_splice_cursor() {
5 use rustix::io::{pipe, splice, SpliceFlags};
6 use std::io::{Read, Seek, SeekFrom, Write};
7
8 let mut src = tempfile::tempfile().unwrap();
9 let mut dest = tempfile::tempfile().unwrap();
10 let (read_p, write_p) = pipe().unwrap();
11 let mut buff = vec![];
12
13 writeln!(src, "hello world").unwrap();
14
15 src.seek(SeekFrom::Start(6)).unwrap();
16
17 splice(&src, None, &write_p, None, 5, SpliceFlags::empty()).unwrap();
18 splice(&read_p, None, &dest, None, 5, SpliceFlags::empty()).unwrap();
19
20 // When we can depend on Rust 1.55, we can use `rewind` here.
21 dest.seek(SeekFrom::Start(0)).unwrap();
22
23 dest.read_to_end(&mut buff).unwrap();
24 assert_eq!(buff, b"world");
25 }
26
27 #[cfg(feature = "fs")]
28 #[cfg(any(target_os = "android", target_os = "linux"))]
29 #[test]
test_splice_offset()30 fn test_splice_offset() {
31 use rustix::io::{pipe, splice, SpliceFlags};
32 use std::io::{Read, Write};
33
34 let mut src = tempfile::tempfile().unwrap();
35 let mut dest = tempfile::tempfile().unwrap();
36 let (read_p, write_p) = pipe().unwrap();
37 let mut buff = vec![];
38 let mut off_w = 0;
39 let mut off_r = 0;
40
41 writeln!(src, "hello world").unwrap();
42
43 splice(
44 &src,
45 Some(&mut off_w),
46 &write_p,
47 None,
48 5,
49 SpliceFlags::empty(),
50 )
51 .unwrap();
52 splice(
53 &read_p,
54 None,
55 &dest,
56 Some(&mut off_r),
57 5,
58 SpliceFlags::empty(),
59 )
60 .unwrap();
61
62 dest.read_to_end(&mut buff).unwrap();
63 assert_eq!(buff, b"hello");
64 assert_eq!(off_w, 5);
65 assert_eq!(off_r, 5);
66 }
67
68 #[cfg(feature = "fs")]
69 #[cfg(any(target_os = "android", target_os = "linux"))]
70 #[test]
test_splice_pipe2pipe()71 fn test_splice_pipe2pipe() {
72 use rustix::io::{pipe, read, splice, write, SpliceFlags};
73
74 let (read_p1, write_p1) = pipe().unwrap();
75 let (read_p2, write_p2) = pipe().unwrap();
76 let mut buff = [0; 5];
77
78 write(&write_p1, b"hello").unwrap();
79 splice(&read_p1, None, write_p2, None, 5, SpliceFlags::empty()).unwrap();
80 read(&read_p2, &mut buff).unwrap();
81
82 assert_eq!(&buff, b"hello");
83 }
84
85 #[cfg(feature = "fs")]
86 #[cfg(any(target_os = "android", target_os = "linux"))]
87 #[test]
test_vmsplice_write()88 fn test_vmsplice_write() {
89 use rustix::io::{pipe, read, vmsplice, IoSliceRaw, SpliceFlags};
90
91 let (read_p, write_p) = pipe().unwrap();
92 let mut output = [0; 11];
93 let input = [
94 IoSliceRaw::from_slice(b"hello"),
95 IoSliceRaw::from_slice(b" "),
96 IoSliceRaw::from_slice(b"world"),
97 ];
98
99 unsafe { vmsplice(&write_p, &input, SpliceFlags::empty()).unwrap() };
100 read(&read_p, &mut output).unwrap();
101
102 assert_eq!(&output, b"hello world");
103 }
104
105 #[cfg(feature = "fs")]
106 #[cfg(any(target_os = "android", target_os = "linux"))]
107 #[test]
test_vmsplice_read()108 fn test_vmsplice_read() {
109 use rustix::io::{pipe, vmsplice, write, IoSliceRaw, SpliceFlags};
110
111 let (read_p, write_p) = pipe().unwrap();
112 let mut outputs = ([0; 5], [0; 1], [0; 5]);
113 let outputs_slices = [
114 IoSliceRaw::from_slice_mut(&mut outputs.0),
115 IoSliceRaw::from_slice_mut(&mut outputs.1),
116 IoSliceRaw::from_slice_mut(&mut outputs.2),
117 ];
118
119 write(&write_p, b"hello world").unwrap();
120 unsafe { vmsplice(&read_p, &outputs_slices, SpliceFlags::empty()).unwrap() };
121
122 assert_eq!(&outputs.0, b"hello");
123 assert_eq!(&outputs.1, b" ");
124 assert_eq!(&outputs.2, b"world");
125 }
126