Debian Codegraph @

.cargo/vendor/lebe/tests/tests.rs

raw
1 extern crate lebe;
2
3 use lebe::prelude::*;
4 use std::mem;
5
6 use byteorder::{WriteBytesExt, LittleEndian, BigEndian, ReadBytesExt};
7
8 #[test]
9 fn make_le_u32_slice() {
10 // as seen on https://doc.rust-lang.org/std/primitive.u32.html#method.to_le
11 let n = 0x1Au32;
12
13 let mut n_le = [n];
14 n_le.convert_current_to_little_endian();
15
16 if cfg!(target_endian = "little") {
17 assert_eq!(n_le, [n])
18 }
19 else {
20 assert_eq!(n_le, [u32::swap_bytes(n)])
21 }
22
23 // assert_eq!(n_le, byteorder::LittleEndian::from_)
24 }
25
26 #[test]
27 fn make_be_u32_slice() {
28 // as seen on https://doc.rust-lang.org/std/primitive.u32.html#method.to_be
29 let n = 0x1Au32;
30
31 let mut n_be = [n];
32 n_be.convert_current_to_big_endian();
33
34 if cfg!(target_endian = "big") {
35 assert_eq!(n_be, [n])
36 }
37 else {
38 assert_eq!(n_be, [n.swap_bytes()])
39 }
40 }
41
42 #[test]
43 fn make_le_u16_slice() {
44 // as seen on https://doc.rust-lang.org/std/primitive.u16.html#method.to_le
45 let n = 0x1Au16;
46
47 let mut n_le = [n];
48 n_le.convert_current_to_little_endian();
49
50 if cfg!(target_endian = "little") {
51 assert_eq!(n_le, [n])
52 }
53 else {
54 assert_eq!(n_le, [n.swap_bytes()])
55 }
56 }
57
58 #[test]
59 fn make_le_i64_slice() {
60 // as seen on https://doc.rust-lang.org/std/primitive.u64.html#method.to_be
61 let n1 = 0x14F3EEBCCD93895A_i64;
62 let n2 = 0x114F3EF99B81CC5A_i64;
63
64 let mut n_be = [n1, n2];
65 n_be.convert_current_to_big_endian();
66
67 if cfg!(target_endian = "big") {
68 assert_eq!(n_be, [n1, n2])
69 }
70 else {
71 assert_eq!(n_be, [n1.swap_bytes(), n2.swap_bytes()])
72 }
73 }
74
75 #[test]
76 fn make_be_f64() {
77 let i = 0x14F3EEBCCD93895A_u64;
78
79 let mut f: f64 = unsafe { mem::transmute(i) };
80 f.convert_current_to_big_endian();
81
82 assert_eq!(f, unsafe { mem::transmute(i.to_be()) })
83 }
84
85 #[test]
86 fn into_be_f64() {
87 let i = 0x14F3EEBCCD93895A_u64;
88
89 let f: f64 = unsafe { mem::transmute(i) };
90 let f = f.from_current_into_big_endian();
91
92 assert_eq!(f, unsafe { mem::transmute(i.to_be()) })
93 }
94
95 #[test]
96 fn into_be_i16() {
97 let i = 0x195A_i16;
98 let be = i.from_current_into_big_endian();
99
100 if cfg!(target_endian = "big") {
101 assert_eq!(be, i)
102 }
103 else {
104 assert_eq!(be, i.swap_bytes())
105 }
106 }
107
108 #[test]
109 fn into_be_u32() {
110 let i = 0x1220943_u32;
111 let be = i.from_current_into_big_endian();
112
113 if cfg!(target_endian = "big") {
114 assert_eq!(be, i)
115 }
116 else {
117 assert_eq!(be, i.swap_bytes())
118 }
119 }
120
121 #[test]
122 fn cmp_read_be_u16() {
123 let read: &[u8] = &[0x33, 0xbb];
124 let a = u16::read_from_big_endian(&mut read.clone()).unwrap();
125 let b: u16 = read.clone().read_from_big_endian().unwrap();
126 let c = read.clone().read_u16::<BigEndian>().unwrap();
127
128 assert_eq!(a, b);
129 assert_eq!(a, c);
130 }
131
132 #[test]
133 fn cmp_read_le_u16() {
134 let read: &[u8] = &[0x33, 0xbb];
135 let a = u16::read_from_little_endian(&mut read.clone()).unwrap();
136 let b: u16 = read.clone().read_from_little_endian().unwrap();
137 let c = read.clone().read_u16::<LittleEndian>().unwrap();
138
139 assert_eq!(a, b);
140 assert_eq!(a, c);
141 }
142
143 #[test]
144 fn cmp_read_le_f32() {
145 let read: &[u8] = &[0x33, 0xBB, 0x44, 0xCC];
146 let a = f32::read_from_little_endian(&mut read.clone()).unwrap();
147 let b: f32 = read.clone().read_from_little_endian().unwrap();
148 let c = read.clone().read_f32::<LittleEndian>().unwrap();
149
150 assert_eq!(a, b);
151 assert_eq!(a, c);
152 }
153
154 #[test]
155 fn cmp_read_be_slice() {
156 let mut write_expected = Vec::new();
157 let mut write_actual = Vec::new();
158
159 let data: Vec<f32> = (0..31*31).map(|i| i as f32).collect();
160
161 for number in &data {
162 write_expected.write_f32::<BigEndian>(*number).unwrap();
163 }
164
165 write_actual.write_as_big_endian(data.as_slice()).unwrap();
166 assert_eq!(write_actual, write_expected);
167 }
168
169 #[test]
170 fn cmp_write_le_slice() {
171 let mut write_expected = Vec::new();
172 let mut write_actual = Vec::new();
173
174 let data: Vec<f32> = (0..31*31).map(|i| i as f32).collect();
175
176 for number in &data {
177 write_expected.write_f32::<LittleEndian>(*number).unwrap();
178 }
179
180 write_actual.write_as_little_endian(data.as_slice()).unwrap();
181
182 assert_eq!(write_actual, write_expected);
183 }
184
185 #[test]
186 fn cmp_write_le_u32() {
187 let mut write_expected = Vec::new();
188 let mut write_actual = Vec::new();
189
190 let data = 0x23573688_u32;
191 write_expected.write_u32::<LittleEndian>(data).unwrap();
192 write_actual.write_as_little_endian(&data).unwrap();
193
194 assert_eq!(write_actual, write_expected);
195 }
196
197
198
199 #[test]
200 fn cmp_write_le_slice_u64() {
201 let mut write_expected = Vec::new();
202 let mut write_actual = Vec::new();
203
204 let data: Vec<u64> = (1000..1000+310*31).map(|i| i as u64).collect();
205
206 for number in &data {
207 write_expected.write_u64::<LittleEndian>(*number).unwrap();
208 }
209
210 write_actual.write_as_little_endian(data.as_slice()).unwrap();
211
212 assert_eq!(write_actual, write_expected);
213 }