< prev index next >

test/jdk/java/util/concurrent/tck/ConcurrentLinkedDequeTest.java

Print this page
8234131: Miscellaneous changes imported from jsr166 CVS 2020-12
Reviewed-by: martin


 993                 else
 994                     throw new AssertionError(
 995                         String.format(
 996                             "unexpected value %d after %d nulls and %d zeros",
 997                             x, nulls.sum(), zeros.sum()));
 998             };
 999 
1000             Runnable adder = () -> { d.addLast(0); d.addFirst(42); };
1001 
1002             runAsync(getter, adder);
1003         }
1004     }
1005 
1006     /**
1007      * Non-traversing Deque operations (that return null) are linearizable.
1008      * Don't return null when the deque is observably never empty.
1009      * https://bugs.openjdk.java.net/browse/JDK-8189387
1010      * ant -Djsr166.expensiveTests=true -Djsr166.tckTestClass=ConcurrentLinkedDequeTest -Djsr166.methodFilter=testBug8189387 tck
1011      */
1012     public void testBug8189387() {
1013         final ThreadLocalRandom rnd = ThreadLocalRandom.current();
1014         Object x = new Object();
1015         for (int n = expensiveTests ? 100_000 : 10; n--> 0; ) {
1016             ConcurrentLinkedDeque<Object> d = new ConcurrentLinkedDeque<>();
1017             Runnable add = chooseRandomly(
1018                 () -> d.addFirst(x),
1019                 () -> d.offerFirst(x),
1020                 () -> d.addLast(x),
1021                 () -> d.offerLast(x));
1022 
1023             Runnable get = chooseRandomly(
1024                 () -> assertFalse(d.isEmpty()),
1025                 () -> assertSame(x, d.peekFirst()),
1026                 () -> assertSame(x, d.peekLast()),
1027                 () -> assertSame(x, d.pollFirst()),
1028                 () -> assertSame(x, d.pollLast()));
1029 
1030             Runnable addRemove = chooseRandomly(
1031                 () -> { d.addFirst(x); d.pollLast(); },
1032                 () -> { d.offerFirst(x); d.removeFirst(); },
1033                 () -> { d.offerLast(x); d.removeLast(); },


 993                 else
 994                     throw new AssertionError(
 995                         String.format(
 996                             "unexpected value %d after %d nulls and %d zeros",
 997                             x, nulls.sum(), zeros.sum()));
 998             };
 999 
1000             Runnable adder = () -> { d.addLast(0); d.addFirst(42); };
1001 
1002             runAsync(getter, adder);
1003         }
1004     }
1005 
1006     /**
1007      * Non-traversing Deque operations (that return null) are linearizable.
1008      * Don't return null when the deque is observably never empty.
1009      * https://bugs.openjdk.java.net/browse/JDK-8189387
1010      * ant -Djsr166.expensiveTests=true -Djsr166.tckTestClass=ConcurrentLinkedDequeTest -Djsr166.methodFilter=testBug8189387 tck
1011      */
1012     public void testBug8189387() {

1013         Object x = new Object();
1014         for (int n = expensiveTests ? 100_000 : 10; n--> 0; ) {
1015             ConcurrentLinkedDeque<Object> d = new ConcurrentLinkedDeque<>();
1016             Runnable add = chooseRandomly(
1017                 () -> d.addFirst(x),
1018                 () -> d.offerFirst(x),
1019                 () -> d.addLast(x),
1020                 () -> d.offerLast(x));
1021 
1022             Runnable get = chooseRandomly(
1023                 () -> assertFalse(d.isEmpty()),
1024                 () -> assertSame(x, d.peekFirst()),
1025                 () -> assertSame(x, d.peekLast()),
1026                 () -> assertSame(x, d.pollFirst()),
1027                 () -> assertSame(x, d.pollLast()));
1028 
1029             Runnable addRemove = chooseRandomly(
1030                 () -> { d.addFirst(x); d.pollLast(); },
1031                 () -> { d.offerFirst(x); d.removeFirst(); },
1032                 () -> { d.offerLast(x); d.removeLast(); },
< prev index next >