FIFO priority queue properties where the key is equal to the top key

mperry · mperry · commit e5bc0e1bddb3 · 2016-06-18T22:16:11.000+10:00
diff --git a/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java b/props-core/src/test/java/fj/data/properties/PriorityQueueProperties.java
@@ -17,10 +17,14 @@
 import static fj.data.PriorityQueue.emptyInt;
 import static fj.test.Arbitrary.arbAlphaNumString;
 import static fj.test.Arbitrary.arbInteger;
+import static fj.test.Arbitrary.arbList;
+import static fj.test.Arbitrary.arbP2;
 import static fj.test.Arbitrary.arbSet;
 import static fj.test.Property.impliesBoolean;
 import static fj.test.Property.prop;
 import static fj.test.Property.property;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
 
 /**
  * Created by MarkPerry on 18 Jun 16.
@@ -29,7 +33,7 @@
 @CheckParams(maxSize = 100)
 public class PriorityQueueProperties {
 
-    public static Gen<PriorityQueue<Integer, String>> arbPriorityQueueIntegerString = arbUniqueQueue(arbAlphaNumString);
+    public static Gen<PriorityQueue<Integer, String>> arbPriorityQueueIntegerString = arbQueue(arbAlphaNumString);
 
     /**
      * Returns a queue with unique integer priorities.
@@ -43,6 +47,11 @@ public static <A> Gen<PriorityQueue<Integer, A>> arbUniqueQueue(Gen<A> aa) {
         return (alp.map(l -> PriorityQueue.<A>emptyInt().enqueue(l)));
     }
 
+    public static <A> Gen<PriorityQueue<Integer, A>> arbQueue(Gen<A> aa) {
+        Gen<List<P2<Integer, A>>> g = arbList(arbP2(arbInteger, aa));
+        return g.map(l -> PriorityQueue.<A>emptyInt().enqueue(l));
+    }
+
     Property empty() {
         PriorityQueue<Integer, Object> pq = emptyInt();
         return prop(pq.isEmpty());
@@ -53,11 +62,10 @@ Property empty() {
      */
     Property addRemove() {
         return property(arbPriorityQueueIntegerString, arbInteger, arbAlphaNumString, (q, i, s) -> {
-            Option<P2<Integer, String>> o = q.top();
-            Option<P2<Integer, String>> o2 = q.enqueue(i, s).dequeue().top();
-            return Property.impliesBoolean(
-                    q.isGreaterThan(Ord.intOrd, i),
-                    () -> o.equals(o2)
+            Option<P2<Integer, String>> t1 = q.top();
+            Option<P2<Integer, String>> t2 = q.enqueue(i, s).dequeue().top();
+            return prop(q.isLessThan(Ord.intOrd, i) ?
+                    t1.equals(t2) : t2.map(p -> p._1() >= i).orSome(true)
             );
         });
     }
@@ -75,20 +83,36 @@ Property emptyTop() {
     Property addTop() {
         return property(arbPriorityQueueIntegerString, arbInteger, arbAlphaNumString, (q, i, s) -> {
             Option<P2<Integer, String>> actual = q.enqueue(i, s).top();
-            return impliesBoolean(
-                    q.isGreaterThan(Ord.intOrd, i),
-                    actual.equals(some(P.p(i, s))));
+            return prop(q.isLessThan(Ord.intOrd, i) ? actual.equals(some(P.p(i, s))) : actual.equals(q.top()));
         });
     }
 
     /**
-     * Sorting a list returns the same as putting the list into a priority queue and getting
-     * the queue as a list.
+     * Sorting a list returns the same as putting the list into a priority queue and getting the queue as a list.
      */
     public Property sorted() {
         return property(arbPriorityQueueIntegerString, pq -> {
             List<P2<Integer, String>> expected = pq.toList().sort(Ord.p2Ord1(Ord.intOrd.reverse()));
-            return prop(expected.equals(pq.toList()));
+            List<P2<Integer, String>> actual = pq.toList();
+            assertThat(actual, equalTo(expected));
+            return prop(actual.equals(expected));
+        });
+    }
+
+    /**
+     * Where the top n of the queue has just one element then:
+     * - Enqueueing and then topN of the queue should return a list of the top and the new item
+     * - Enqueuing and then dequeueing and then topping the queue should return the new item
+     */
+    Property singleTopSame() {
+        return property(arbPriorityQueueIntegerString, arbAlphaNumString, (pq, s) -> {
+            Option<Integer> o1 = pq.top().map(p -> p._1());
+            return o1.map(j -> {
+                boolean b = pq.topN().length() == 1;
+                Property p1 = impliesBoolean(b, () -> pq.enqueue(j, s).dequeue().top().equals(some(P.p(j, s))));
+                Property p2 = impliesBoolean(b, () -> pq.enqueue(j, s).topN().equals(List.list(pq.top().some(), P.p(j, s))));
+                return p1.and(p2);
+            }).orSome(prop(true));
         });
     }
 
