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.30 by jsr166, Tue Oct 10 05:54:41 2017 UTC vs.
Revision 1.36 by jsr166, Mon Dec 16 21:13:07 2019 UTC

# Line 662 | Line 662 | public class ConcurrentLinkedDequeTest e
662       */
663      public void testToArray() {
664          ConcurrentLinkedDeque q = populatedDeque(SIZE);
665 <        Object[] o = q.toArray();
666 <        for (int i = 0; i < o.length; i++)
667 <            assertSame(o[i], q.poll());
665 >        Object[] a = q.toArray();
666 >        assertSame(Object[].class, a.getClass());
667 >        for (Object o : a)
668 >            assertSame(o, q.poll());
669 >        assertTrue(q.isEmpty());
670      }
671  
672      /**
# Line 675 | Line 677 | public class ConcurrentLinkedDequeTest e
677          Integer[] ints = new Integer[SIZE];
678          Integer[] array = q.toArray(ints);
679          assertSame(ints, array);
680 <        for (int i = 0; i < ints.length; i++)
681 <            assertSame(ints[i], q.poll());
680 >        for (Integer o : ints)
681 >            assertSame(o, q.poll());
682 >        assertTrue(q.isEmpty());
683      }
684  
685      /**
# Line 685 | Line 688 | public class ConcurrentLinkedDequeTest e
688      public void testToArray_NullArg() {
689          ConcurrentLinkedDeque q = populatedDeque(SIZE);
690          try {
691 <            q.toArray(null);
691 >            q.toArray((Object[])null);
692              shouldThrow();
693          } catch (NullPointerException success) {}
694      }
# Line 909 | Line 912 | public class ConcurrentLinkedDequeTest e
912          }
913      }
914  
915 +    void runAsync(Runnable r1, Runnable r2) {
916 +        boolean b = randomBoolean();
917 +        CompletableFuture<Void> f1 = CompletableFuture.runAsync(b ? r1 : r2);
918 +        CompletableFuture<Void> f2 = CompletableFuture.runAsync(b ? r2 : r1);
919 +        f1.join();
920 +        f2.join();
921 +    }
922 +
923      /**
924       * Non-traversing Deque operations are linearizable.
925       * https://bugs.openjdk.java.net/browse/JDK-8188900
# Line 932 | Line 943 | public class ConcurrentLinkedDequeTest e
943                              x, nulls.sum(), zeros.sum()));
944              };
945  
946 <            Runnable adder = () -> {
936 <                d.addFirst(0);
937 <                d.addLast(42);
938 <            };
946 >            Runnable adder = () -> { d.addFirst(0); d.addLast(42); };
947  
948 <            boolean b = rnd.nextBoolean();
941 <            Runnable r1 = b ? getter : adder;
942 <            Runnable r2 = b ? adder : getter;
943 <            CompletableFuture<Void> f1 = CompletableFuture.runAsync(r1);
944 <            CompletableFuture<Void> f2 = CompletableFuture.runAsync(r2);
945 <            f1.join();
946 <            f2.join();
948 >            runAsync(getter, adder);
949          }
950      }
951  
# Line 968 | Line 970 | public class ConcurrentLinkedDequeTest e
970                              x, nulls.sum(), zeros.sum()));
971              };
972  
973 <            Runnable adder = () -> {
974 <                d.addLast(0);
975 <                d.addFirst(42);
976 <            };
973 >            Runnable adder = () -> { d.addLast(0); d.addFirst(42); };
974 >
975 >            runAsync(getter, adder);
976 >        }
977 >    }
978 >
979 >    /**
980 >     * Non-traversing Deque operations (that return null) are linearizable.
981 >     * Don't return null when the deque is observably never empty.
982 >     * https://bugs.openjdk.java.net/browse/JDK-8189387
983 >     * ant -Djsr166.expensiveTests=true -Djsr166.tckTestClass=ConcurrentLinkedDequeTest -Djsr166.methodFilter=testBug8189387 tck
984 >     */
985 >    public void testBug8189387() {
986 >        Object x = new Object();
987 >        for (int n = expensiveTests ? 100_000 : 10; n--> 0; ) {
988 >            ConcurrentLinkedDeque<Object> d = new ConcurrentLinkedDeque<>();
989 >            Runnable add = chooseRandomly(
990 >                () -> d.addFirst(x),
991 >                () -> d.offerFirst(x),
992 >                () -> d.addLast(x),
993 >                () -> d.offerLast(x));
994 >
995 >            Runnable get = chooseRandomly(
996 >                () -> assertFalse(d.isEmpty()),
997 >                () -> assertSame(x, d.peekFirst()),
998 >                () -> assertSame(x, d.peekLast()),
999 >                () -> assertSame(x, d.pollFirst()),
1000 >                () -> assertSame(x, d.pollLast()));
1001 >
1002 >            Runnable addRemove = chooseRandomly(
1003 >                () -> { d.addFirst(x); d.pollLast(); },
1004 >                () -> { d.offerFirst(x); d.removeFirst(); },
1005 >                () -> { d.offerLast(x); d.removeLast(); },
1006 >                () -> { d.addLast(x); d.pollFirst(); });
1007  
1008 <            boolean b = rnd.nextBoolean();
1009 <            Runnable r1 = b ? getter : adder;
978 <            Runnable r2 = b ? adder : getter;
979 <            CompletableFuture<Void> f1 = CompletableFuture.runAsync(r1);
980 <            CompletableFuture<Void> f2 = CompletableFuture.runAsync(r2);
981 <            f1.join();
982 <            f2.join();
1008 >            add.run();
1009 >            runAsync(get, addRemove);
1010          }
1011      }
1012   }

Diff Legend

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