1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package com.google.common.collect;
18
19 import static com.google.common.collect.testing.IteratorFeature.UNMODIFIABLE;
20 import static com.google.common.truth.Truth.assertThat;
21
22 import com.google.common.annotations.GwtCompatible;
23 import com.google.common.annotations.GwtIncompatible;
24 import com.google.common.collect.testing.IteratorTester;
25
26 import junit.framework.AssertionFailedError;
27 import junit.framework.TestCase;
28
29 import java.util.Iterator;
30 import java.util.NoSuchElementException;
31
32
33 @GwtCompatible(emulated = true)
34 public class AbstractSequentialIteratorTest extends TestCase {
35 @GwtIncompatible("Too slow")
36 public void testDoublerExhaustive() {
37 new IteratorTester<Integer>(3, UNMODIFIABLE, ImmutableList.of(1, 2),
38 IteratorTester.KnownOrder.KNOWN_ORDER) {
39 @Override
40 protected Iterator<Integer> newTargetIterator() {
41 return newDoubler(1, 2);
42 }
43 }.test();
44 }
45
46 public void testDoubler() {
47 Iterable<Integer> doubled = new Iterable<Integer>() {
48 @Override
49 public Iterator<Integer> iterator() {
50 return newDoubler(2, 32);
51 }
52 };
53 assertThat(doubled).iteratesAs(2, 4, 8, 16, 32);
54 }
55
56 public void testSampleCode() {
57 Iterable<Integer> actual = new Iterable<Integer>() {
58 @Override
59 public Iterator<Integer> iterator() {
60 Iterator<Integer> powersOfTwo = new AbstractSequentialIterator<Integer>(1) {
61 protected Integer computeNext(Integer previous) {
62 return (previous == 1 << 30) ? null : previous * 2;
63 }
64 };
65 return powersOfTwo;
66 }
67 };
68 assertThat(actual).iteratesAs(1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048,
69 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288, 1048576, 2097152, 4194304,
70 8388608, 16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824);
71 }
72
73 public void testEmpty() {
74 Iterator<Object> empty = newEmpty();
75 assertFalse(empty.hasNext());
76 try {
77 empty.next();
78 fail();
79 } catch (NoSuchElementException expected) {
80 }
81 try {
82 empty.remove();
83 fail();
84 } catch (UnsupportedOperationException expected) {
85 }
86 }
87
88 public void testBroken() {
89 Iterator<Object> broken = newBroken();
90 assertTrue(broken.hasNext());
91
92 try {
93 broken.next();
94 fail();
95 } catch (MyException expected) {
96 }
97 try {
98 broken.next();
99 fail();
100 } catch (MyException expected) {
101 }
102 }
103
104 private static Iterator<Integer> newDoubler(int first, final int last) {
105 return new AbstractSequentialIterator<Integer>(first) {
106 @Override
107 protected Integer computeNext(Integer previous) {
108 return (previous == last) ? null : previous * 2;
109 }
110 };
111 }
112
113 private static <T> Iterator<T> newEmpty() {
114 return new AbstractSequentialIterator<T>(null) {
115 @Override
116 protected T computeNext(T previous) {
117 throw new AssertionFailedError();
118 }
119 };
120 }
121
122 private static Iterator<Object> newBroken() {
123 return new AbstractSequentialIterator<Object>("UNUSED") {
124 @Override
125 protected Object computeNext(Object previous) {
126 throw new MyException();
127 }
128 };
129 }
130
131 private static class MyException extends RuntimeException {}
132 }