1 #![allow(bad_style)]
2
3 use std::iter::FromIterator;
4 use tinyvec::*;
5
6 #[test]
test_a_vec()7 fn test_a_vec() {
8 let mut expected: ArrayVec<[i32; 4]> = Default::default();
9 expected.push(1);
10 expected.push(2);
11 expected.push(3);
12
13 let actual = array_vec!([i32; 4], 1, 2, 3);
14
15 assert_eq!(expected, actual);
16 }
17
18 #[test]
ArrayVec_push_pop()19 fn ArrayVec_push_pop() {
20 let mut av: ArrayVec<[i32; 4]> = Default::default();
21 assert_eq!(av.len(), 0);
22 assert_eq!(av.pop(), None);
23
24 av.push(10_i32);
25 assert_eq!(av.len(), 1);
26 assert_eq!(av[0], 10);
27 assert_eq!(av.pop(), Some(10));
28 assert_eq!(av.len(), 0);
29 assert_eq!(av.pop(), None);
30
31 av.push(10);
32 av.push(11);
33 av.push(12);
34 av.push(13);
35 assert_eq!(av[0], 10);
36 assert_eq!(av[1], 11);
37 assert_eq!(av[2], 12);
38 assert_eq!(av[3], 13);
39 assert_eq!(av.len(), 4);
40 assert_eq!(av.pop(), Some(13));
41 assert_eq!(av.len(), 3);
42 assert_eq!(av.pop(), Some(12));
43 assert_eq!(av.len(), 2);
44 assert_eq!(av.pop(), Some(11));
45 assert_eq!(av.len(), 1);
46 assert_eq!(av.pop(), Some(10));
47 assert_eq!(av.len(), 0);
48 assert_eq!(av.pop(), None);
49 }
50
51 #[test]
52 #[should_panic]
ArrayVec_push_overflow()53 fn ArrayVec_push_overflow() {
54 let mut av: ArrayVec<[i32; 0]> = Default::default();
55 av.push(7);
56 }
57
58 #[test]
ArrayVec_formatting()59 fn ArrayVec_formatting() {
60 // check that we get the comma placement correct
61
62 let mut av: ArrayVec<[i32; 4]> = Default::default();
63 assert_eq!(format!("{:?}", av), "[]");
64 av.push(10);
65 assert_eq!(format!("{:?}", av), "[10]");
66 av.push(11);
67 assert_eq!(format!("{:?}", av), "[10, 11]");
68 av.push(12);
69 assert_eq!(format!("{:?}", av), "[10, 11, 12]");
70
71 // below here just asserts that the impls exist.
72
73 //
74 let av: ArrayVec<[i32; 4]> = Default::default();
75 assert_eq!(format!("{:b}", av), "[]");
76 assert_eq!(format!("{:o}", av), "[]");
77 assert_eq!(format!("{:x}", av), "[]");
78 assert_eq!(format!("{:X}", av), "[]");
79 assert_eq!(format!("{}", av), "[]");
80 //
81 let av: ArrayVec<[f32; 4]> = Default::default();
82 assert_eq!(format!("{:e}", av), "[]");
83 assert_eq!(format!("{:E}", av), "[]");
84 //
85 let av: ArrayVec<[&'static str; 4]> = Default::default();
86 assert_eq!(format!("{:p}", av), "[]");
87 }
88
89 #[test]
ArrayVec_iteration()90 fn ArrayVec_iteration() {
91 let av = array_vec!([i32; 4], 10, 11, 12, 13);
92
93 let mut i = av.into_iter();
94 assert_eq!(i.next(), Some(10));
95 assert_eq!(i.next(), Some(11));
96 assert_eq!(i.next(), Some(12));
97 assert_eq!(i.next(), Some(13));
98 assert_eq!(i.next(), None);
99
100 let av = array_vec!([i32; 4], 10, 11, 12, 13);
101
102 let av2: ArrayVec<[i32; 4]> = av.clone().into_iter().collect();
103 assert_eq!(av, av2);
104 }
105
106 #[test]
ArrayVec_append()107 fn ArrayVec_append() {
108 let mut av = array_vec!([i32; 8], 1, 2, 3);
109 let mut av2 = array_vec!([i32; 8], 4, 5, 6);
110 //
111 av.append(&mut av2);
112 assert_eq!(av.as_slice(), &[1_i32, 2, 3, 4, 5, 6]);
113 assert_eq!(av2.as_slice(), &[]);
114 }
115
116 #[test]
ArrayVec_remove()117 fn ArrayVec_remove() {
118 let mut av: ArrayVec<[i32; 10]> = Default::default();
119 av.push(1);
120 av.push(2);
121 av.push(3);
122 assert_eq!(av.remove(1), 2);
123 assert_eq!(&av[..], &[1, 3][..]);
124 }
125
126 #[test]
127 #[should_panic]
ArrayVec_remove_invalid()128 fn ArrayVec_remove_invalid() {
129 let mut av: ArrayVec<[i32; 1]> = Default::default();
130 av.push(1);
131 av.remove(1);
132 }
133
134 #[test]
ArrayVec_swap_remove()135 fn ArrayVec_swap_remove() {
136 let mut av: ArrayVec<[i32; 10]> = Default::default();
137 av.push(1);
138 av.push(2);
139 av.push(3);
140 av.push(4);
141 assert_eq!(av.swap_remove(3), 4);
142 assert_eq!(&av[..], &[1, 2, 3][..]);
143 assert_eq!(av.swap_remove(0), 1);
144 assert_eq!(&av[..], &[3, 2][..]);
145 assert_eq!(av.swap_remove(0), 3);
146 assert_eq!(&av[..], &[2][..]);
147 assert_eq!(av.swap_remove(0), 2);
148 assert_eq!(&av[..], &[][..]);
149 }
150
151 #[test]
ArrayVec_drain()152 fn ArrayVec_drain() {
153 let mut av: ArrayVec<[i32; 10]> = Default::default();
154 av.push(1);
155 av.push(2);
156 av.push(3);
157
158 assert_eq!(Vec::from_iter(av.clone().drain(..)), vec![1, 2, 3]);
159
160 assert_eq!(Vec::from_iter(av.clone().drain(..2)), vec![1, 2]);
161 assert_eq!(Vec::from_iter(av.clone().drain(..3)), vec![1, 2, 3]);
162
163 assert_eq!(Vec::from_iter(av.clone().drain(..=1)), vec![1, 2]);
164 assert_eq!(Vec::from_iter(av.clone().drain(..=2)), vec![1, 2, 3]);
165
166 assert_eq!(Vec::from_iter(av.clone().drain(0..)), vec![1, 2, 3]);
167 assert_eq!(Vec::from_iter(av.clone().drain(1..)), vec![2, 3]);
168
169 assert_eq!(Vec::from_iter(av.clone().drain(0..2)), vec![1, 2]);
170 assert_eq!(Vec::from_iter(av.clone().drain(0..3)), vec![1, 2, 3]);
171 assert_eq!(Vec::from_iter(av.clone().drain(1..2)), vec![2]);
172 assert_eq!(Vec::from_iter(av.clone().drain(1..3)), vec![2, 3]);
173
174 assert_eq!(Vec::from_iter(av.clone().drain(0..=1)), vec![1, 2]);
175 assert_eq!(Vec::from_iter(av.clone().drain(0..=2)), vec![1, 2, 3]);
176 assert_eq!(Vec::from_iter(av.clone().drain(1..=1)), vec![2]);
177 assert_eq!(Vec::from_iter(av.clone().drain(1..=2)), vec![2, 3]);
178 }
179