1#[cfg(test)]
2use crate::{
3 address::Address,
4 builder::Builder,
5 bytes::Bytes,
6 bytesfix::stable::Bytes4,
7 function::Function,
8};
9#[cfg(test)]
10use std::convert::TryFrom;
11
12#[test]
13#[rustfmt::skip]
14fn number_test() {
15 let buf = Builder::new()
16 .push(0xffu8 as i8)
17 .push(0xffu8)
18 .push(0xffffu16 as i16)
19 .push(0xffffu16)
20 .push(0xffffffffu32 as i32)
21 .push(0xffffffffu32)
22 .push(0xffffffffffffffffu64 as i64)
23 .push(0xffffffffffffffffu64)
24 .push(0xffffffffffffffffffffffffffffffffu128 as i128)
25 .push(0xffffffffffffffffffffffffffffffffu128)
26 .build();
27 let first = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
28 let second = hex::decode("00000000000000000000000000000000000000000000000000000000000000ff").unwrap();
29 let third = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
30 let forth = hex::decode("000000000000000000000000000000000000000000000000000000000000ffff").unwrap();
31 let fifth = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
32 let sixth = hex::decode("00000000000000000000000000000000000000000000000000000000ffffffff").unwrap();
33 let seventh = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
34 let eighth = hex::decode("000000000000000000000000000000000000000000000000ffffffffffffffff").unwrap();
35 let nineth = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
36 let tenth = hex::decode("00000000000000000000000000000000ffffffffffffffffffffffffffffffff").unwrap();
37
38 assert_eq!(&first[0..32], &buf[32 * 0..32 * 1]);
39 assert_eq!(&second[0..32], &buf[32 * 1..32 * 2]);
40 assert_eq!(&third[0..32], &buf[32 * 2..32 * 3]);
41 assert_eq!(&forth[0..32], &buf[32 * 3..32 * 4]);
42 assert_eq!(&fifth[0..32], &buf[32 * 4..32 * 5]);
43 assert_eq!(&sixth[0..32], &buf[32 * 5..32 * 6]);
44 assert_eq!(&seventh[0..32], &buf[32 * 6..32 * 7]);
45 assert_eq!(&eighth[0..32], &buf[32 * 7..32 * 8]);
46 assert_eq!(&nineth[0..32], &buf[32 * 8..32 * 9]);
47 assert_eq!(&tenth[0..32], &buf[32 * 9..32 * 10]);
48}
49
50#[test]
51#[rustfmt::skip]
52fn byte_test() {
53 let buf = Builder::new().push(Bytes("random bytes".as_bytes())).build();
54 let first_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000020").unwrap();
55 let first_len = hex::decode("000000000000000000000000000000000000000000000000000000000000000c").unwrap();
56 let first_data = hex::decode("72616E646F6D206279746573000000000000000000000000000000000000000000").unwrap();
57
58 assert_eq!(96, buf.len());
59 assert_eq!(&first_offset[0..32], &buf[32 * 0..32 * 1]);
60 assert_eq!(&first_len[0..32], &buf[32 * 1..32 * 2]);
61 assert_eq!(&first_data[0..32], &buf[32 * 2..32 * 3]);
62}
63
64#[test]
65#[rustfmt::skip]
66fn string_test() {
67 let buf = Builder::new().push("random bytes".to_string()).build();
68 let first_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000020").unwrap();
69 let first_len = hex::decode("000000000000000000000000000000000000000000000000000000000000000c").unwrap();
70 let first_data = hex::decode("72616e646f6d206279746573000000000000000000000000000000000000000000").unwrap();
71
72 assert_eq!(96, buf.len());
73 assert_eq!(&first_offset[0..32], &buf[32 * 0..32 * 1]);
74 assert_eq!(&first_len[0..32], &buf[32 * 1..32 * 2]);
75 assert_eq!(&first_data[0..32], &buf[32 * 2..32 * 3]);
76}
77
78#[test]
79#[rustfmt::skip]
80fn byte_n_test() {
81 let buf = Builder::new().push(Bytes4([0xff; 4])).build();
82 let first = hex::decode("ffffffff00000000000000000000000000000000000000000000000000000000").unwrap();
83
84 assert_eq!(32, buf.len());
85 assert_eq!(&first[0..32], &buf[0..32]);
86}
87
88#[test]
89#[rustfmt::skip]
90fn array_number_test() {
91 let buf = Builder::new()
92 .push([0xffu8 as i8; 2].to_vec())
93 .push([0xffu8; 2].to_vec())
94 .push([0xffffu16 as i16; 2].to_vec())
95 .push([0xffffu16; 2].to_vec())
96 .push([0xffffffffu32 as i32; 2].to_vec())
97 .push([0xffffffffu32; 2].to_vec())
98 .push([0xffffffffffffffffu64 as i64; 2].to_vec())
99 .push([0xffffffffffffffffu64; 2].to_vec())
100 .push([0xffffffffffffffffffffffffffffffffu128 as i128; 2].to_vec())
101 .push([0xffffffffffffffffffffffffffffffffu128; 2].to_vec())
102 .build();
103
104 let i8_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000140").unwrap();
105 let u8_offset = hex::decode("00000000000000000000000000000000000000000000000000000000000001a0").unwrap();
106 let i16_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000200").unwrap();
107 let u16_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000260").unwrap();
108 let i32_offset = hex::decode("00000000000000000000000000000000000000000000000000000000000002c0").unwrap();
109 let u32_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000320").unwrap();
110 let i64_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000380").unwrap();
111 let u64_offset = hex::decode("00000000000000000000000000000000000000000000000000000000000003e0").unwrap();
112 let i128_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000440").unwrap();
113 let u128_offset = hex::decode("00000000000000000000000000000000000000000000000000000000000004a0").unwrap();
114 let i8_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000002").unwrap();
115 let i8_1 = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
116 let i8_2 = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
117 let u8_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000002").unwrap();
118 let u8_1 = hex::decode("00000000000000000000000000000000000000000000000000000000000000ff").unwrap();
119 let u8_2 = hex::decode("00000000000000000000000000000000000000000000000000000000000000ff").unwrap();
120 let i16_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000002").unwrap();
121 let i16_1 = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
122 let i16_2 = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
123 let u16_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000002").unwrap();
124 let u16_1 = hex::decode("000000000000000000000000000000000000000000000000000000000000ffff").unwrap();
125 let u16_2 = hex::decode("000000000000000000000000000000000000000000000000000000000000ffff").unwrap();
126 let i32_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000002").unwrap();
127 let i32_1 = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
128 let i32_2 = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
129 let u32_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000002").unwrap();
130 let u32_1 = hex::decode("00000000000000000000000000000000000000000000000000000000ffffffff").unwrap();
131 let u32_2 = hex::decode("00000000000000000000000000000000000000000000000000000000ffffffff").unwrap();
132 let i64_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000002").unwrap();
133 let i64_1 = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
134 let i64_2 = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
135 let u64_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000002").unwrap();
136 let u64_1 = hex::decode("000000000000000000000000000000000000000000000000ffffffffffffffff").unwrap();
137 let u64_2 = hex::decode("000000000000000000000000000000000000000000000000ffffffffffffffff").unwrap();
138 let i128_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000002").unwrap();
139 let i128_1 = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
140 let i128_2 = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff").unwrap();
141 let u128_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000002").unwrap();
142 let u128_1 = hex::decode("00000000000000000000000000000000ffffffffffffffffffffffffffffffff").unwrap();
143 let u128_2 = hex::decode("00000000000000000000000000000000ffffffffffffffffffffffffffffffff").unwrap();
144
145 assert_eq!(&i8_offset[0..32], &buf[32 * 0..32 * 1]);
147 assert_eq!(&u8_offset[0..32], &buf[32 * 1..32 * 2]);
148 assert_eq!(&i16_offset[0..32], &buf[32 * 2..32 * 3]);
149 assert_eq!(&u16_offset[0..32], &buf[32 * 3..32 * 4]);
150 assert_eq!(&i32_offset[0..32], &buf[32 * 4..32 * 5]);
151 assert_eq!(&u32_offset[0..32], &buf[32 * 5..32 * 6]);
152 assert_eq!(&i64_offset[0..32], &buf[32 * 6..32 * 7]);
153 assert_eq!(&u64_offset[0..32], &buf[32 * 7..32 * 8]);
154 assert_eq!(&i128_offset[0..32], &buf[32 * 8..32 * 9]);
155 assert_eq!(&u128_offset[0..32], &buf[32 * 9..32 * 10]);
156 assert_eq!(&i8_len[0..32], &buf[32 * 10..32 * 11]);
157 assert_eq!(&i8_1[0..32], &buf[32 * 11..32 * 12]);
158 assert_eq!(&i8_2[0..32], &buf[32 * 12..32 * 13]);
159 assert_eq!(&u8_len[0..32], &buf[32 * 13..32 * 14]);
160 assert_eq!(&u8_1[0..32], &buf[32 * 14..32 * 15]);
161 assert_eq!(&u8_2[0..32], &buf[32 * 15..32 * 16]);
162 assert_eq!(&i16_len[0..32], &buf[32 * 16..32 * 17]);
163 assert_eq!(&i16_1[0..32], &buf[32 * 17..32 * 18]);
164 assert_eq!(&i16_2[0..32], &buf[32 * 18..32 * 19]);
165 assert_eq!(&u16_len[0..32], &buf[32 * 19..32 * 20]);
166 assert_eq!(&u16_1[0..32], &buf[32 * 20..32 * 21]);
167 assert_eq!(&u16_2[0..32], &buf[32 * 21..32 * 22]);
168 assert_eq!(&i32_len[0..32], &buf[32 * 22..32 * 23]);
169 assert_eq!(&i32_1[0..32], &buf[32 * 23..32 * 24]);
170 assert_eq!(&i32_2[0..32], &buf[32 * 24..32 * 25]);
171 assert_eq!(&u32_len[0..32], &buf[32 * 25..32 * 26]);
172 assert_eq!(&u32_1[0..32], &buf[32 * 26..32 * 27]);
173 assert_eq!(&u32_2[0..32], &buf[32 * 27..32 * 28]);
174 assert_eq!(&i64_len[0..32], &buf[32 * 28..32 * 29]);
175 assert_eq!(&i64_1[0..32], &buf[32 * 29..32 * 30]);
176 assert_eq!(&i64_2[0..32], &buf[32 * 30..32 * 31]);
177 assert_eq!(&u64_len[0..32], &buf[32 * 31..32 * 32]);
178 assert_eq!(&u64_1[0..32], &buf[32 * 32..32 * 33]);
179 assert_eq!(&u64_2[0..32], &buf[32 * 33..32 * 34]);
180 assert_eq!(&i128_len[0..32], &buf[32 * 34..32 * 35]);
181 assert_eq!(&i128_1[0..32], &buf[32 * 35..32 * 36]);
182 assert_eq!(&i128_2[0..32], &buf[32 * 36..32 * 37]);
183 assert_eq!(&u128_len[0..32], &buf[32 * 37..32 * 38]);
184 assert_eq!(&u128_1[0..32], &buf[32 * 38..32 * 39]);
185 assert_eq!(&u128_2[0..32], &buf[32 * 39..32 * 40]);
186}
187
188#[test]
189#[rustfmt::skip]
190fn bytes_array_test() {
191 let buf = Builder::new()
192 .push(vec![Bytes(&[0xaau8; 16]), Bytes(&[0xffu8; 16])])
193 .push(vec!["random string".to_string(), "what about another one".to_string()])
194 .build();
195
196 let bytes_array_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000040").unwrap();
197 let string_array_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000120").unwrap();
198 let bytes_array_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000002").unwrap();
199 let bytes_array_1_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000040").unwrap();
200 let bytes_array_2_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000080").unwrap();
201 let bytes_array_1_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000010").unwrap();
202 let bytes_array_1_bytes = hex::decode("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000000000000000000000000000").unwrap();
203 let bytes_array_2_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000010").unwrap();
204 let bytes_array_2_bytes = hex::decode("ffffffffffffffffffffffffffffffff00000000000000000000000000000000").unwrap();
205 let string_array_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000002").unwrap();
206 let string_array_1_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000040").unwrap();
207 let string_array_2_offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000080").unwrap();
208 let string_array_1_len = hex::decode("000000000000000000000000000000000000000000000000000000000000000d").unwrap();
209 let string_array_1_bytes = hex::decode("72616e646f6d20737472696e6700000000000000000000000000000000000000").unwrap();
210 let string_array_2_len = hex::decode("0000000000000000000000000000000000000000000000000000000000000016").unwrap();
211 let string_array_2_bytes = hex::decode("776861742061626f757420616e6f74686572206f6e6500000000000000000000").unwrap();
212
213 assert_eq!(&bytes_array_offset[0..32], &buf[32 * 0..32 * 1]);
214 assert_eq!(&string_array_offset[0..32], &buf[32 * 1..32 * 2]);
215 assert_eq!(&bytes_array_len[0..32], &buf[32 * 2..32 * 3]);
216 assert_eq!(&bytes_array_1_offset[0..32], &buf[32 * 3..32 * 4]);
217 assert_eq!(&bytes_array_2_offset[0..32], &buf[32 * 4..32 * 5]);
218 assert_eq!(&bytes_array_1_len[0..32], &buf[32 * 5..32 * 6]);
219 assert_eq!(&bytes_array_1_bytes[0..32], &buf[32 * 6..32 * 7]);
220 assert_eq!(&bytes_array_2_len[0..32], &buf[32 * 7..32 * 8]);
221 assert_eq!(&bytes_array_2_bytes[0..32], &buf[32 * 8..32 * 9]);
222 assert_eq!(&string_array_len[0..32], &buf[32 * 9..32 * 10]);
223 assert_eq!(&string_array_1_offset[0..32], &buf[32 * 10..32 * 11]);
224 assert_eq!(&string_array_2_offset[0..32], &buf[32 * 11..32 * 12]);
225 assert_eq!(&string_array_1_len[0..32], &buf[32 * 12..32 * 13]);
226 assert_eq!(&string_array_1_bytes[0..32], &buf[32 * 13..32 * 14]);
227 assert_eq!(&string_array_2_len[0..32], &buf[32 * 14..32 * 15]);
228 assert_eq!(&string_array_2_bytes[0..32], &buf[32 * 15..32 * 16]);
229}
230
231#[test]
232#[rustfmt::skip]
233fn address_test() -> Result<(), anyhow::Error> {
234 let buf = Builder::new().push(Address::try_from(&[0xffu8; 20][..])?).build();
235
236 let address = hex::decode("000000000000000000000000ffffffffffffffffffffffffffffffffffffffff").unwrap();
237
238 assert_eq!(&address[0..32], &buf[32 * 0..32 * 1]);
239
240 Ok(())
241}
242
243#[test]
244#[rustfmt::skip]
245fn function_test() -> Result<(), anyhow::Error> {
246 let buf = Builder::new().push(Function::try_from(&[0xffu8; 24][..])?).build();
247
248 let function = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000").unwrap();
249
250 assert_eq!(&function[0..32], &buf[32 * 0..32 * 1]);
251
252 Ok(())
253}
254
255#[test]
256#[rustfmt::skip]
257fn hex_test() -> Result<(), anyhow::Error> {
258 let buf = Builder::new().push(Function::try_from("0xffffffffffffffffffffffffffffffffffffffffffffffff")?).build();
259
260 let function = hex::decode("ffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000").unwrap();
261
262 assert_eq!(&function[0..32], &buf[32 * 0..32 * 1]);
263
264 Ok(())
265}
266
267#[test]
268#[rustfmt::skip]
269fn tuple_test() -> Result<(), anyhow::Error> {
270 let buf = Builder::new().push((0xffu8, 0xaabbu16)).build();
271
272 let offset = hex::decode("0000000000000000000000000000000000000000000000000000000000000020").unwrap();
273 let tuple1 = hex::decode("00000000000000000000000000000000000000000000000000000000000000ff").unwrap();
274 let tuple2 = hex::decode("000000000000000000000000000000000000000000000000000000000000aabb").unwrap();
275
276 assert_eq!(&offset[0..32], &buf[32 * 0..32 * 1]);
277 assert_eq!(&tuple1[0..32], &buf[32 * 1..32 * 2]);
278 assert_eq!(&tuple2[0..32], &buf[32 * 2..32 * 3]);
279
280 Ok(())
281}