11 |
|
import java.util.ArrayList; |
12 |
|
import java.util.Arrays; |
13 |
|
import java.util.Collection; |
14 |
+ |
import java.util.Collections; |
15 |
|
import java.util.Iterator; |
16 |
|
import java.util.NoSuchElementException; |
17 |
|
import java.util.Queue; |
105 |
|
/** |
106 |
|
* Constructor throws IAE if capacity argument nonpositive |
107 |
|
*/ |
108 |
< |
public void testConstructor2() { |
109 |
< |
try { |
110 |
< |
new ArrayBlockingQueue(0); |
111 |
< |
shouldThrow(); |
112 |
< |
} catch (IllegalArgumentException success) {} |
108 |
> |
public void testConstructor_nonPositiveCapacity() { |
109 |
> |
for (int i : new int[] { 0, -1, Integer.MIN_VALUE }) { |
110 |
> |
try { |
111 |
> |
new ArrayBlockingQueue(i); |
112 |
> |
shouldThrow(); |
113 |
> |
} catch (IllegalArgumentException success) {} |
114 |
> |
for (boolean fair : new boolean[] { true, false }) { |
115 |
> |
try { |
116 |
> |
new ArrayBlockingQueue(i, fair); |
117 |
> |
shouldThrow(); |
118 |
> |
} catch (IllegalArgumentException success) {} |
119 |
> |
} |
120 |
> |
} |
121 |
|
} |
122 |
|
|
123 |
|
/** |
124 |
|
* Initializing from null Collection throws NPE |
125 |
|
*/ |
126 |
< |
public void testConstructor3() { |
126 |
> |
public void testConstructor_nullCollection() { |
127 |
|
try { |
128 |
|
new ArrayBlockingQueue(1, true, null); |
129 |
|
shouldThrow(); |
158 |
|
/** |
159 |
|
* Initializing from too large collection throws IAE |
160 |
|
*/ |
161 |
< |
public void testConstructor6() { |
162 |
< |
Integer[] ints = new Integer[SIZE]; |
163 |
< |
for (int i = 0; i < SIZE; ++i) |
164 |
< |
ints[i] = i; |
156 |
< |
Collection<Integer> elements = Arrays.asList(ints); |
161 |
> |
public void testConstructor_collectionTooLarge() { |
162 |
> |
// just barely fits - succeeds |
163 |
> |
new ArrayBlockingQueue(SIZE, false, |
164 |
> |
Collections.nCopies(SIZE, "")); |
165 |
|
try { |
166 |
< |
new ArrayBlockingQueue(SIZE - 1, false, elements); |
166 |
> |
new ArrayBlockingQueue(SIZE - 1, false, |
167 |
> |
Collections.nCopies(SIZE, "")); |
168 |
|
shouldThrow(); |
169 |
|
} catch (IllegalArgumentException success) {} |
170 |
|
} |
186 |
|
* Queue transitions from empty to full when elements added |
187 |
|
*/ |
188 |
|
public void testEmptyFull() { |
189 |
< |
ArrayBlockingQueue q = new ArrayBlockingQueue(2); |
189 |
> |
BlockingQueue q = populatedQueue(0, 2, 2, false); |
190 |
|
assertTrue(q.isEmpty()); |
191 |
|
assertEquals(2, q.remainingCapacity()); |
192 |
|
q.add(one); |
193 |
|
assertFalse(q.isEmpty()); |
194 |
< |
q.add(two); |
194 |
> |
assertTrue(q.offer(two)); |
195 |
|
assertFalse(q.isEmpty()); |
196 |
|
assertEquals(0, q.remainingCapacity()); |
197 |
|
assertFalse(q.offer(three)); |
201 |
|
* remainingCapacity decreases on add, increases on remove |
202 |
|
*/ |
203 |
|
public void testRemainingCapacity() { |
204 |
< |
BlockingQueue q = populatedQueue(SIZE); |
205 |
< |
for (int i = 0; i < SIZE; ++i) { |
206 |
< |
assertEquals(i, q.remainingCapacity()); |
207 |
< |
assertEquals(SIZE, q.size() + q.remainingCapacity()); |
204 |
> |
int size = ThreadLocalRandom.current().nextInt(1, SIZE); |
205 |
> |
BlockingQueue q = populatedQueue(size, size, 2 * size, false); |
206 |
> |
int spare = q.remainingCapacity(); |
207 |
> |
int capacity = spare + size; |
208 |
> |
for (int i = 0; i < size; i++) { |
209 |
> |
assertEquals(spare + i, q.remainingCapacity()); |
210 |
> |
assertEquals(capacity, q.size() + q.remainingCapacity()); |
211 |
|
assertEquals(i, q.remove()); |
212 |
|
} |
213 |
< |
for (int i = 0; i < SIZE; ++i) { |
214 |
< |
assertEquals(SIZE - i, q.remainingCapacity()); |
215 |
< |
assertEquals(SIZE, q.size() + q.remainingCapacity()); |
213 |
> |
for (int i = 0; i < size; i++) { |
214 |
> |
assertEquals(capacity - i, q.remainingCapacity()); |
215 |
> |
assertEquals(capacity, q.size() + q.remainingCapacity()); |
216 |
|
assertTrue(q.add(i)); |
217 |
|
} |
218 |
|
} |