]>
git.proxmox.com Git - rustc.git/blob - vendor/generic-array/tests/iter.rs
2 extern crate generic_array
;
7 use generic_array
::GenericArray
;
8 use generic_array
::typenum
::consts
::U5
;
11 fn test_into_iter_as_slice() {
12 let array
= arr
![char; 'a'
, 'b'
, 'c'
];
13 let mut into_iter
= array
.into_iter();
14 assert_eq
!(into_iter
.as_slice(), &['a'
, 'b'
, 'c'
]);
15 let _
= into_iter
.next().unwrap();
16 assert_eq
!(into_iter
.as_slice(), &['b'
, 'c'
]);
17 let _
= into_iter
.next().unwrap();
18 let _
= into_iter
.next().unwrap();
19 assert_eq
!(into_iter
.as_slice(), &[]);
23 fn test_into_iter_as_mut_slice() {
24 let array
= arr
![char; 'a'
, 'b'
, 'c'
];
25 let mut into_iter
= array
.into_iter();
26 assert_eq
!(into_iter
.as_slice(), &['a'
, 'b'
, 'c'
]);
27 into_iter
.as_mut_slice()[0] = 'x'
;
28 into_iter
.as_mut_slice()[1] = 'y'
;
29 assert_eq
!(into_iter
.next().unwrap(), 'x'
);
30 assert_eq
!(into_iter
.as_slice(), &['y'
, 'c'
]);
34 fn test_into_iter_debug() {
35 let array
= arr
![char; 'a'
, 'b'
, 'c'
];
36 let into_iter
= array
.into_iter();
37 let debug
= format
!("{:?}", into_iter
);
38 assert_eq
!(debug
, "GenericArrayIter(['a', 'b', 'c'])");
42 fn test_into_iter_clone() {
43 fn iter_equal
<I
: Iterator
<Item
= i32>>(it
: I
, slice
: &[i32]) {
44 let v
: Vec
<i32> = it
.collect();
45 assert_eq
!(&v
[..], slice
);
47 let mut it
= arr
![i32; 1, 2, 3].into_iter();
48 iter_equal(it
.clone(), &[1, 2, 3]);
49 assert_eq
!(it
.next(), Some(1));
50 let mut it
= it
.rev();
51 iter_equal(it
.clone(), &[3, 2]);
52 assert_eq
!(it
.next(), Some(3));
53 iter_equal(it
.clone(), &[2]);
54 assert_eq
!(it
.next(), Some(2));
55 iter_equal(it
.clone(), &[]);
56 assert_eq
!(it
.next(), None
);
60 fn test_into_iter_nth() {
61 let v
= arr
![i32; 0, 1, 2, 3, 4];
63 assert_eq
!(v
.clone().into_iter().nth(i
).unwrap(), v
[i
]);
65 assert_eq
!(v
.clone().into_iter().nth(v
.len()), None
);
67 let mut iter
= v
.into_iter();
68 assert_eq
!(iter
.nth(2).unwrap(), v
[2]);
69 assert_eq
!(iter
.nth(1).unwrap(), v
[4]);
73 fn test_into_iter_last() {
74 let v
= arr
![i32; 0, 1, 2, 3, 4];
75 assert_eq
!(v
.into_iter().last().unwrap(), 4);
76 assert_eq
!(arr
![i32; 0].into_iter().last().unwrap(), 0);
80 fn test_into_iter_count() {
81 let v
= arr
![i32; 0, 1, 2, 3, 4];
82 assert_eq
!(v
.clone().into_iter().count(), 5);
84 let mut iter2
= v
.into_iter();
87 assert_eq
!(iter2
.count(), 3);
91 fn test_into_iter_flat_map() {
92 assert
!((0..5).flat_map(|i
| arr
![i32; 2 * i
, 2 * i
+ 1]).eq(0..10));
96 fn test_into_iter_drops() {
101 impl<'a
> Drop
for R
<'a
> {
103 self.i
.set(self.i
.get() + 1);
107 fn r(i
: &Cell
<usize>) -> R
{
113 fn v(i
: &Cell
<usize>) -> GenericArray
<R
, U5
> {
114 arr
![R
; r(i
), r(i
), r(i
), r(i
), r(i
)]
117 let i
= Cell
::new(0);
121 assert_eq
!(i
.get(), 5);
123 let i
= Cell
::new(0);
125 let mut iter
= v(&i
).into_iter();
126 let _x
= iter
.next();
127 assert_eq
!(i
.get(), 0);
128 assert_eq
!(iter
.count(), 4);
129 assert_eq
!(i
.get(), 4);
131 assert_eq
!(i
.get(), 5);
133 let i
= Cell
::new(0);
135 let mut iter
= v(&i
).into_iter();
136 let _x
= iter
.nth(2);
137 assert_eq
!(i
.get(), 2);
138 let _y
= iter
.last();
139 assert_eq
!(i
.get(), 3);
141 assert_eq
!(i
.get(), 5);
143 let i
= Cell
::new(0);
144 for (index
, _x
) in v(&i
).into_iter().enumerate() {
145 assert_eq
!(i
.get(), index
);
147 assert_eq
!(i
.get(), 5);
149 let i
= Cell
::new(0);
150 for (index
, _x
) in v(&i
).into_iter().rev().enumerate() {
151 assert_eq
!(i
.get(), index
);
153 assert_eq
!(i
.get(), 5);
159 fn assert_covariance() {
160 fn into_iter<'new>(i: GenericArrayIter<&'static str, U10>) -> GenericArrayIter<&'new str, U10> {