Create mock versions set and sort implementations.

dart/frog/leg/lib/dual_pivot_quicksort.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+// TODO(ahe): Remove this file and use the shared one.
+
 /**
  * Dual-Pivot Quicksort algorithm.
  *
  * This class implements the dual-pivot quicksort algorithm as presented in
  * Vladimir Yaroslavskiy's paper.
  *
  * Some improvements have been copied from Android's implementation.
  */
 class DualPivotQuicksort {
   // When a list has less then [:_INSERTION_SORT_THRESHOLD:] elements it will
@@ skipping 113 matching lines @@
       // a[left] and a[right] are undefined and are filled after the
       // partitioning.
       //
       // Invariants:
       //   1) for x in ]left, less[ : x < pivot.
       //   2) for x in [less, k[ : x == pivot.
       //   3) for x in ]great, right[ : x > pivot.
       for (int k = less; k <= great; k++) {
         var ak = a[k];
         int comp = compare(ak, pivot);
-        if (comp == 0) continue;
-        if (comp < 0) {
+        if (comp == 0) {
+        } else if (comp < 0) {
           if (k != less) {
             a[k] = a[less];
             a[less] = ak;
           }
           less++;
         } else {
           // comp > 0.
           //
           // Find the first element <= pivot in the range [k - 1, great] and
           // put [:ak:] there. We know that such an element must exist:
           // When k == less, then el3 (which is equal to pivot) lies in the
           // interval. Otherwise a[k - 1] == pivot and the search stops at k-1.
           // Note that in the latter case invariant 2 will be violated for a
           // short amount of time. The invariant will be restored when the
           // pivots are put into their final positions.
           while (true) {
             comp = compare(a[great], pivot);
             if (comp > 0) {
               great--;
               // This is the only location in the while-loop where a new
               // iteration is started.
-              continue;
+              // continue;
             } else if (comp < 0) {
               // Triple exchange.
               a[k] = a[less];
               a[less++] = a[great];
               a[great--] = ak;
               break;
             } else {
               // comp == 0;
               a[k] = a[great];
               a[great--] = ak;
@@ skipping 34 matching lines @@
         } else {
           int comp_pivot2 = compare(ak, pivot2);
           if (comp_pivot2 > 0) {
             while (true) {
               int comp = compare(a[great], pivot2);
               if (comp > 0) {
                 great--;
                 if (great < k) break;
                 // This is the only location inside the loop where a new
                 // iteration is started.
-                continue;
+                // continue;
               } else {
                 // a[great] <= pivot2.
                 comp = compare(a[great], pivot1);
                 if (comp < 0) {
                   // Triple exchange.
                   a[k] = a[less];
                   a[less++] = a[great];
                   a[great--] = ak;
                 } else {
                   // a[great] >= pivot1.
@@ skipping 69 matching lines @@
         } else {
           int comp_pivot2 = compare(ak, pivot2);
           if (comp_pivot2 == 0) {
             while (true) {
               int comp = compare(a[great], pivot2);
               if (comp == 0) {
                 great--;
                 if (great < k) break;
                 // This is the only location inside the loop where a new
                 // iteration is started.
-                continue;
+                // continue;
               } else {
                 // a[great] < pivot2.
                 comp = compare(a[great], pivot1);
                 if (comp < 0) {
                   // Triple exchange.
                   a[k] = a[less];
                   a[less++] = a[great];
                   a[great--] = ak;
                 } else {
                   // a[great] == pivot1.
@@ skipping 16 matching lines @@
     } else {
       // The second partition looks as follows:
       // [  *  |  >= pivot1 && <= pivot2  | * ]
       //        ^                        ^
       //       less                    great
       // Simply sort it by recursive descent.
       _doSort(a, less, great, compare);
     }
   }
 }