1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License
15 */
16
17package libcore.java.util;
18
19import junit.framework.TestCase;
20
21import java.util.ArrayList;
22import java.util.Arrays;
23import java.util.List;
24import java.util.PrimitiveIterator;
25import java.util.function.Consumer;
26import java.util.function.DoubleConsumer;
27import java.util.function.IntConsumer;
28import java.util.function.LongConsumer;
29
30public class PrimitiveIteratorTest extends TestCase {
31    public static class CannedIntIterator implements PrimitiveIterator.OfInt {
32        private final int[] ints;
33        private int idx;
34
35        public CannedIntIterator(int[] ints) {
36            this.ints = ints;
37            this.idx = 0;
38        }
39
40        @Override
41        public int nextInt() {
42            return ints[idx++];
43        }
44
45        @Override
46        public boolean hasNext() {
47            return idx < ints.length;
48        }
49    }
50
51    public static class CannedLongIterator implements PrimitiveIterator.OfLong {
52        private final long[] longs;
53        private int idx;
54
55        public CannedLongIterator(long[] longs) {
56            this.longs = longs;
57            this.idx = 0;
58        }
59
60        @Override
61        public long nextLong() {
62            return longs[idx++];
63        }
64
65        @Override
66        public boolean hasNext() {
67            return idx < longs.length;
68        }
69    }
70
71    public static class CannedDoubleIterator implements PrimitiveIterator.OfDouble {
72        private final double[] doubles;
73        private int idx;
74
75        public CannedDoubleIterator(double[] doubles) {
76            this.doubles = doubles;
77            this.idx = 0;
78        }
79
80        @Override
81        public double nextDouble() {
82            return doubles[idx++];
83        }
84
85        @Override
86        public boolean hasNext() {
87            return idx < doubles.length;
88        }
89    }
90
91    public void testIntIterator_forEachRemaining_Consumer() {
92        final int[] data = new int[] { 1, 2, 4, 5 };
93
94        final ArrayList<Integer> recorder = new ArrayList<>();
95        CannedIntIterator cit = new CannedIntIterator(data);
96        cit.forEachRemaining((int i) -> recorder.add(i));
97
98        assertEquals(Arrays.asList(1, 2, 4, 5), recorder);
99
100        cit = new CannedIntIterator(data);
101        try {
102            cit.forEachRemaining((IntConsumer) null);
103            fail();
104        } catch (NullPointerException expected) {
105        }
106    }
107
108    public void testIntIterator_forEachRemaining_boxedConsumer() {
109        final int[] data = new int[] { 1, 2, 4, 5 };
110
111        final ArrayList<Integer> recorder = new ArrayList<>();
112        CannedIntIterator cit = new CannedIntIterator(data);
113        cit.forEachRemaining((Integer i) -> recorder.add(i));
114
115        assertEquals(Arrays.asList(1, 2, 4, 5), recorder);
116
117        // Test that the boxed and unboxed iterators produce the same
118        // set of events.
119        final ArrayList<Integer> recorder2 = new ArrayList<>();
120        cit = new CannedIntIterator(data);
121        cit.forEachRemaining((int i) -> recorder2.add(i));
122        assertEquals(recorder, recorder2);
123
124        cit = new CannedIntIterator(data);
125        try {
126            cit.forEachRemaining((Consumer<Integer>) null);
127            fail();
128        } catch (NullPointerException expected) {
129        }
130    }
131
132    public void testIntIterator_forEachRemaining_boxedNext() {
133        final int[] data = new int[] { 1 };
134        CannedIntIterator cit = new CannedIntIterator(data);
135        assertEquals(1, (int) cit.next());
136    }
137
138    public void testLongIterator_forEachRemaining_Consumer() {
139        final long[] data = new long[] { 1, 2, 4, 5 };
140
141        final ArrayList<Long> recorder = new ArrayList<>();
142        CannedLongIterator cit = new CannedLongIterator(data);
143        cit.forEachRemaining((long i) -> recorder.add(i));
144
145        assertEquals(Arrays.asList(1L, 2L, 4L, 5L), recorder);
146
147        cit = new CannedLongIterator(data);
148        try {
149            cit.forEachRemaining((LongConsumer) null);
150            fail();
151        } catch (NullPointerException expected) {
152        }
153    }
154
155    public void testLongIterator_forEachRemaining_boxedConsumer() {
156        final long[] data = new long[] { 1, 2, 4, 5 };
157
158        final ArrayList<Long> recorder = new ArrayList<>();
159        CannedLongIterator cit = new CannedLongIterator(data);
160        cit.forEachRemaining((Long i) -> recorder.add(i));
161
162        assertEquals(Arrays.asList(1L, 2L, 4L, 5L), recorder);
163
164        // Test that the boxed and unboxed iterators produce the same
165        // set of events.
166        final ArrayList<Long> recorder2 = new ArrayList<>();
167        cit = new CannedLongIterator(data);
168        cit.forEachRemaining((long i) -> recorder2.add(i));
169        assertEquals(recorder, recorder2);
170
171        cit = new CannedLongIterator(data);
172        try {
173            cit.forEachRemaining((Consumer<Long>) null);
174            fail();
175        } catch (NullPointerException expected) {
176        }
177    }
178
179    public void testLongIterator_forEachRemaining_boxedNext() {
180        final long[] data = new long[] { 1L };
181        CannedLongIterator clt = new CannedLongIterator(data);
182        assertEquals(1, (long) clt.next());
183    }
184
185    public void testDoubleIterator_forEachRemaining_Consumer() {
186        final double[] data = new double[] { 1, 2, 4, 5 };
187
188        final ArrayList<Double> recorder = new ArrayList<>();
189        CannedDoubleIterator cit = new CannedDoubleIterator(data);
190        cit.forEachRemaining((double i) -> recorder.add(i));
191
192        assertEquals(Arrays.asList(1.0d, 2.0d, 4.0d, 5.0d), recorder);
193
194        cit = new CannedDoubleIterator(data);
195        try {
196            cit.forEachRemaining((DoubleConsumer) null);
197            fail();
198        } catch (NullPointerException expected) {
199        }
200    }
201
202    public void testDoubleIterator_forEachRemaining_boxedConsumer() {
203        final double[] data = new double[] { 1, 2, 4, 5 };
204
205        final ArrayList<Double> recorder = new ArrayList<>();
206        CannedDoubleIterator cit = new CannedDoubleIterator(data);
207        cit.forEachRemaining((Double i) -> recorder.add(i));
208
209        assertEquals(Arrays.asList(1.0d, 2.0d, 4.0d, 5.0d), recorder);
210
211        // Test that the boxed and unboxed iterators produce the same
212        // set of events.
213        final ArrayList<Double> recorder2 = new ArrayList<>();
214        cit = new CannedDoubleIterator(data);
215        cit.forEachRemaining((double i) -> recorder2.add(i));
216        assertEquals(recorder, recorder2);
217
218        cit = new CannedDoubleIterator(data);
219        try {
220            cit.forEachRemaining((Consumer<Double>) null);
221            fail();
222        } catch (NullPointerException expected) {
223        }
224    }
225
226    public void testDoubleIterator_forEachRemaining_boxedNext() {
227        final double[] data = new double[] { 1.0 };
228        CannedDoubleIterator clt = new CannedDoubleIterator(data);
229        assertEquals(1.0, (double) clt.next());
230    }
231}
232