ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ConcurrentLinkedDequeTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ConcurrentLinkedDequeTest.java (file contents):
Revision 1.19 by jsr166, Sat Apr 25 04:55:30 2015 UTC vs.
Revision 1.22 by jsr166, Sun May 24 01:42:14 2015 UTC

# Line 65 | Line 65 | public class ConcurrentLinkedDequeTest e
65       */
66      public void testConstructor4() {
67          try {
68 <            Integer[] ints = new Integer[SIZE];
69 <            new ConcurrentLinkedDeque(Arrays.asList(ints));
68 >            new ConcurrentLinkedDeque(Arrays.asList(new Integer[SIZE]));
69              shouldThrow();
70          } catch (NullPointerException success) {}
71      }
# Line 75 | Line 74 | public class ConcurrentLinkedDequeTest e
74       * Initializing from Collection with some null elements throws NPE
75       */
76      public void testConstructor5() {
77 +        Integer[] ints = new Integer[SIZE];
78 +        for (int i = 0; i < SIZE - 1; ++i)
79 +            ints[i] = new Integer(i);
80          try {
79 –            Integer[] ints = new Integer[SIZE];
80 –            for (int i = 0; i < SIZE-1; ++i)
81 –                ints[i] = new Integer(i);
81              new ConcurrentLinkedDeque(Arrays.asList(ints));
82              shouldThrow();
83          } catch (NullPointerException success) {}
# Line 116 | Line 115 | public class ConcurrentLinkedDequeTest e
115      public void testSize() {
116          ConcurrentLinkedDeque q = populatedDeque(SIZE);
117          for (int i = 0; i < SIZE; ++i) {
118 <            assertEquals(SIZE-i, q.size());
118 >            assertEquals(SIZE - i, q.size());
119              q.remove();
120          }
121          for (int i = 0; i < SIZE; ++i) {
# Line 129 | Line 128 | public class ConcurrentLinkedDequeTest e
128       * push(null) throws NPE
129       */
130      public void testPushNull() {
131 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
132          try {
133 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
133              q.push(null);
134              shouldThrow();
135          } catch (NullPointerException success) {}
# Line 164 | Line 163 | public class ConcurrentLinkedDequeTest e
163       * offer(null) throws NPE
164       */
165      public void testOfferNull() {
166 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
167          try {
168 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
168              q.offer(null);
169              shouldThrow();
170          } catch (NullPointerException success) {}
# Line 175 | Line 174 | public class ConcurrentLinkedDequeTest e
174       * offerFirst(null) throws NPE
175       */
176      public void testOfferFirstNull() {
177 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
178          try {
179 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
179              q.offerFirst(null);
180              shouldThrow();
181          } catch (NullPointerException success) {}
# Line 186 | Line 185 | public class ConcurrentLinkedDequeTest e
185       * offerLast(null) throws NPE
186       */
187      public void testOfferLastNull() {
188 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
189          try {
190 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
190              q.offerLast(null);
191              shouldThrow();
192          } catch (NullPointerException success) {}
# Line 230 | Line 229 | public class ConcurrentLinkedDequeTest e
229       * add(null) throws NPE
230       */
231      public void testAddNull() {
232 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
233          try {
234 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
234              q.add(null);
235              shouldThrow();
236          } catch (NullPointerException success) {}
# Line 241 | Line 240 | public class ConcurrentLinkedDequeTest e
240       * addFirst(null) throws NPE
241       */
242      public void testAddFirstNull() {
243 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
244          try {
245 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
245              q.addFirst(null);
246              shouldThrow();
247          } catch (NullPointerException success) {}
# Line 252 | Line 251 | public class ConcurrentLinkedDequeTest e
251       * addLast(null) throws NPE
252       */
253      public void testAddLastNull() {
254 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
255          try {
256 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
256              q.addLast(null);
257              shouldThrow();
258          } catch (NullPointerException success) {}
# Line 296 | Line 295 | public class ConcurrentLinkedDequeTest e
295       * addAll(null) throws NPE
296       */
297      public void testAddAll1() {
298 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
299          try {
300 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
300              q.addAll(null);
301              shouldThrow();
302          } catch (NullPointerException success) {}
# Line 307 | Line 306 | public class ConcurrentLinkedDequeTest e
306       * addAll(this) throws IAE
307       */
308      public void testAddAllSelf() {
309 +        ConcurrentLinkedDeque q = populatedDeque(SIZE);
310          try {
311 –            ConcurrentLinkedDeque q = populatedDeque(SIZE);
311              q.addAll(q);
312              shouldThrow();
313          } catch (IllegalArgumentException success) {}
# Line 318 | Line 317 | public class ConcurrentLinkedDequeTest e
317       * addAll of a collection with null elements throws NPE
318       */
319      public void testAddAll2() {
320 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
321          try {
322 <            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
323 <            Integer[] ints = new Integer[SIZE];
324 <            q.addAll(Arrays.asList(ints));
322 >            q.addAll(Arrays.asList(new Integer[SIZE]));
323              shouldThrow();
324          } catch (NullPointerException success) {}
325      }
# Line 331 | Line 329 | public class ConcurrentLinkedDequeTest e
329       * possibly adding some elements
330       */
331      public void testAddAll3() {
332 +        ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
333 +        Integer[] ints = new Integer[SIZE];
334 +        for (int i = 0; i < SIZE - 1; ++i)
335 +            ints[i] = new Integer(i);
336          try {
335 –            ConcurrentLinkedDeque q = new ConcurrentLinkedDeque();
336 –            Integer[] ints = new Integer[SIZE];
337 –            for (int i = 0; i < SIZE-1; ++i)
338 –                ints[i] = new Integer(i);
337              q.addAll(Arrays.asList(ints));
338              shouldThrow();
339          } catch (NullPointerException success) {}
# Line 372 | Line 370 | public class ConcurrentLinkedDequeTest e
370       */
371      public void testPollLast() {
372          ConcurrentLinkedDeque q = populatedDeque(SIZE);
373 <        for (int i = SIZE-1; i >= 0; --i) {
373 >        for (int i = SIZE - 1; i >= 0; --i) {
374              assertEquals(i, q.pollLast());
375          }
376          assertNull(q.pollLast());
# Line 441 | Line 439 | public class ConcurrentLinkedDequeTest e
439              assertTrue(q.contains(i));
440              assertTrue(q.remove(i));
441              assertFalse(q.contains(i));
442 <            assertTrue(q.contains(i-1));
442 >            assertTrue(q.contains(i - 1));
443          }
444          for (int i = 0; i < SIZE; i += 2) {
445              assertTrue(q.contains(i));
446              assertTrue(q.remove(i));
447              assertFalse(q.contains(i));
448 <            assertFalse(q.remove(i+1));
449 <            assertFalse(q.contains(i+1));
448 >            assertFalse(q.remove(i + 1));
449 >            assertFalse(q.contains(i + 1));
450          }
451          assertTrue(q.isEmpty());
452      }
# Line 472 | Line 470 | public class ConcurrentLinkedDequeTest e
470       */
471      public void testPeekLast() {
472          ConcurrentLinkedDeque q = populatedDeque(SIZE);
473 <        for (int i = SIZE-1; i >= 0; --i) {
473 >        for (int i = SIZE - 1; i >= 0; --i) {
474              assertEquals(i, q.peekLast());
475              assertEquals(i, q.pollLast());
476              assertTrue(q.peekLast() == null ||
# Line 501 | Line 499 | public class ConcurrentLinkedDequeTest e
499       */
500      public void testLastElement() {
501          ConcurrentLinkedDeque q = populatedDeque(SIZE);
502 <        for (int i = SIZE-1; i >= 0; --i) {
502 >        for (int i = SIZE - 1; i >= 0; --i) {
503              assertEquals(i, q.getLast());
504              assertEquals(i, q.pollLast());
505          }
# Line 552 | Line 550 | public class ConcurrentLinkedDequeTest e
550          }
551          for (int i = 0; i < SIZE; i += 2) {
552              assertTrue(q.removeFirstOccurrence(new Integer(i)));
553 <            assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
553 >            assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
554          }
555          assertTrue(q.isEmpty());
556      }
# Line 567 | Line 565 | public class ConcurrentLinkedDequeTest e
565          }
566          for (int i = 0; i < SIZE; i += 2) {
567              assertTrue(q.removeLastOccurrence(new Integer(i)));
568 <            assertFalse(q.removeLastOccurrence(new Integer(i+1)));
568 >            assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
569          }
570          assertTrue(q.isEmpty());
571      }
# Line 626 | Line 624 | public class ConcurrentLinkedDequeTest e
624                  assertTrue(changed);
625  
626              assertTrue(q.containsAll(p));
627 <            assertEquals(SIZE-i, q.size());
627 >            assertEquals(SIZE - i, q.size());
628              p.remove();
629          }
630      }
# Line 639 | Line 637 | public class ConcurrentLinkedDequeTest e
637              ConcurrentLinkedDeque q = populatedDeque(SIZE);
638              ConcurrentLinkedDeque p = populatedDeque(i);
639              assertTrue(q.removeAll(p));
640 <            assertEquals(SIZE-i, q.size());
640 >            assertEquals(SIZE - i, q.size());
641              for (int j = 0; j < i; ++j) {
642                  Integer x = (Integer)(p.remove());
643                  assertFalse(q.contains(x));
# Line 755 | Line 753 | public class ConcurrentLinkedDequeTest e
753          final Random rng = new Random();
754          for (int iters = 0; iters < 100; ++iters) {
755              int max = rng.nextInt(5) + 2;
756 <            int split = rng.nextInt(max-1) + 1;
756 >            int split = rng.nextInt(max - 1) + 1;
757              for (int j = 1; j <= max; ++j)
758                  q.add(new Integer(j));
759              Iterator it = q.iterator();
760              for (int j = 1; j <= split; ++j)
761                  assertEquals(it.next(), new Integer(j));
762              it.remove();
763 <            assertEquals(it.next(), new Integer(split+1));
763 >            assertEquals(it.next(), new Integer(split + 1));
764              for (int j = 1; j <= split; ++j)
765                  q.remove(new Integer(j));
766              it = q.iterator();
767 <            for (int j = split+1; j <= max; ++j) {
767 >            for (int j = split + 1; j <= max; ++j) {
768                  assertEquals(it.next(), new Integer(j));
769                  it.remove();
770              }
# Line 823 | Line 821 | public class ConcurrentLinkedDequeTest e
821          final Random rng = new Random();
822          for (int iters = 0; iters < 100; ++iters) {
823              int max = rng.nextInt(5) + 2;
824 <            int split = rng.nextInt(max-1) + 1;
824 >            int split = rng.nextInt(max - 1) + 1;
825              for (int j = max; j >= 1; --j)
826                  q.add(new Integer(j));
827              Iterator it = q.descendingIterator();
828              for (int j = 1; j <= split; ++j)
829                  assertEquals(it.next(), new Integer(j));
830              it.remove();
831 <            assertEquals(it.next(), new Integer(split+1));
831 >            assertEquals(it.next(), new Integer(split + 1));
832              for (int j = 1; j <= split; ++j)
833                  q.remove(new Integer(j));
834              it = q.descendingIterator();
835 <            for (int j = split+1; j <= max; ++j) {
835 >            for (int j = split + 1; j <= max; ++j) {
836                  assertEquals(it.next(), new Integer(j));
837                  it.remove();
838              }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines