array_iterator 0.2.0

Owning iterators based on arrays.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

fn collect<T>(a: impl crate::Array<T>) -> Vec<T> {
	crate::ArrayIterator::new(a).collect()
}

#[test]
fn it_works() {
	assert_eq!(&collect([1, 2, 3]), &[1, 2, 3]);
	assert_eq!(&collect(
		[
			"foo".to_string(),
			"bar".to_string()]),
		&[
			"foo",
			"bar"]);
}

#[test]
fn no_leaks() {
	let i = std::rc::Rc::new(1);
	assert_eq!(&collect([i.clone(), i.clone()]), &[i.clone(), i.clone()]);
	assert_eq!(std::rc::Rc::strong_count(&i), 1);
}

#[test]
fn no_leaks_partial() {
	let i = std::rc::Rc::new(2);
	let mut iter = crate::ArrayIterator::new([
		i.clone(),
		i.clone(),
		i.clone(),
		i.clone(),
		i.clone(),
		i.clone(),
	]);
	
	assert_eq!(std::rc::Rc::strong_count(&i), 7);
	assert_eq!(iter.next(), Some(i.clone()));
	assert_eq!(std::rc::Rc::strong_count(&i), 6);
	assert_eq!(iter.next(), Some(i.clone()));

	std::mem::drop(iter);

	assert_eq!(std::rc::Rc::strong_count(&i), 1);
}

#[test]
fn interative_destruction() {
	let i = std::rc::Rc::new(2);
	let mut iter = crate::ArrayIterator::new([
		i.clone(),
		i.clone(),
		i.clone(),
		i.clone(),
		i.clone(),
		i.clone(),
	]);
	
	assert_eq!(std::rc::Rc::strong_count(&i), 7);
	assert_eq!(iter.next(), Some(i.clone()));
	assert_eq!(std::rc::Rc::strong_count(&i), 6);
	assert_eq!(iter.next(), Some(i.clone()));
	assert_eq!(std::rc::Rc::strong_count(&i), 5);
	assert_eq!(iter.next(), Some(i.clone()));
	assert_eq!(std::rc::Rc::strong_count(&i), 4);
	assert_eq!(iter.next(), Some(i.clone()));
	assert_eq!(std::rc::Rc::strong_count(&i), 3);
	assert_eq!(iter.next(), Some(i.clone()));
	assert_eq!(std::rc::Rc::strong_count(&i), 2);
	assert_eq!(iter.next(), Some(i.clone()));
	assert_eq!(std::rc::Rc::strong_count(&i), 1);

	assert_eq!(iter.next(), None);
	assert_eq!(iter.next(), None);
	assert_eq!(iter.next(), None);
	assert_eq!(iter.next(), None);
}

#[test]
fn len() {
	assert_eq!(crate::ArrayIterator::<(), [(); 0]>::new([]).size_hint(), (0, Some(0)));
	assert_eq!(crate::ArrayIterator::new([1]).size_hint(), (1, Some(1)));
	assert_eq!(crate::ArrayIterator::new([1, 2, 3, 4]).size_hint(), (4, Some(4)));
}

#[test]
fn size_hint_iter() {
	let mut iter = crate::ArrayIterator::new([1, 2, 3, 4]);
	
	assert_eq!(iter.size_hint(), (4, Some(4)));
	assert_eq!(iter.next(), Some(1));
	assert_eq!(iter.size_hint(), (3, Some(3)));
	assert_eq!(iter.next(), Some(2));
	assert_eq!(iter.size_hint(), (2, Some(2)));
	assert_eq!(iter.next(), Some(3));
	assert_eq!(iter.size_hint(), (1, Some(1)));
	assert_eq!(iter.next(), Some(4));
	assert_eq!(iter.size_hint(), (0, Some(0)));
	assert_eq!(iter.next(), None);
	assert_eq!(iter.size_hint(), (0, Some(0)));
}