Add binarySearchFloor() for LongArrays

PiperOrigin-RevId: 291397882

library/common/src/main/java/com/google/android/exoplayer2/util/Util.java

@@ -834,6 +834,47 @@ public final class Util {
     return stayInBounds ? Math.max(0, index) : index;
   }
 
+  /**
+   * Returns the index of the largest element in {@code longArray} that is less than (or optionally
+   * equal to) a specified {@code value}.
+   *
+   * <p>The search is performed using a binary search algorithm, so the array must be sorted. If the
+   * array contains multiple elements equal to {@code value} and {@code inclusive} is true, the
+   * index of the first one will be returned.
+   *
+   * @param longArray The array to search.
+   * @param value The value being searched for.
+   * @param inclusive If the value is present in the array, whether to return the corresponding
+   *     index. If false then the returned index corresponds to the largest element strictly less
+   *     than the value.
+   * @param stayInBounds If true, then 0 will be returned in the case that the value is smaller than
+   *     the smallest element in the array. If false then -1 will be returned.
+   * @return The index of the largest element in {@code array} that is less than (or optionally
+   *     equal to) {@code value}.
+   */
+  public static int binarySearchFloor(
+      LongArray longArray, long value, boolean inclusive, boolean stayInBounds) {
+    int lowIndex = 0;
+    int highIndex = longArray.size() - 1;
+
+    while (lowIndex <= highIndex) {
+      int midIndex = (lowIndex + highIndex) >>> 1;
+      if (longArray.get(midIndex) < value) {
+        lowIndex = midIndex + 1;
+      } else {
+        highIndex = midIndex - 1;
+      }
+    }
+
+    if (inclusive && highIndex + 1 < longArray.size() && longArray.get(highIndex + 1) == value) {
+      highIndex++;
+    } else if (stayInBounds && highIndex == -1) {
+      highIndex = 0;
+    }
+
+    return highIndex;
+  }
+
   /**
    * Returns the index of the smallest element in {@code array} that is greater than (or optionally
    * equal to) a specified {@code value}.

library/common/src/test/java/com/google/android/exoplayer2/util/UtilTest.java

@@ -29,7 +29,6 @@ import com.google.android.exoplayer2.C;
 import com.google.android.exoplayer2.testutil.TestUtil;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.List;
 import java.util.Random;
 import java.util.zip.Deflater;
 import org.junit.Test;
@@ -89,222 +88,596 @@ public class UtilTest {
   }
 
   @Test
-  public void testArrayBinarySearchFloor_emptyArray() {
+  public void arrayBinarySearchFloor_emptyArrayAndStayInBoundsFalse_returnsMinus1() {
-    long[] array = new long[0];
+    assertThat(
-    int target = 0;
+            binarySearchFloor(
-
+                new int[0], /* value= */ 0, /* inclusive= */ false, /* stayInBounds= */ false))
-    assertThat(binarySearchFloor(array, target, /* inclusive= */ false, /* stayInBounds= */ false))
         .isEqualTo(-1);
-    assertThat(binarySearchFloor(array, target, /* inclusive= */ false, /* stayInBounds= */ true))
+  }
+
+  @Test
+  public void arrayBinarySearchFloor_emptyArrayAndStayInBoundsTrue_returns0() {
+    assertThat(
+            binarySearchFloor(
+                new int[0], /* value= */ 0, /* inclusive= */ false, /* stayInBounds= */ true))
         .isEqualTo(0);
   }
 
   @Test
-  public void testArrayBinarySearchFloor_targetSmallerThanArrayValues() {
+  public void arrayBinarySearchFloor_targetSmallerThanValuesAndStayInBoundsFalse_returnsMinus1() {
-    long[] array = new long[] {1, 3, 5};
+    assertThat(
-    int target = 0;
+            binarySearchFloor(
-
+                new int[] {1, 3, 5},
-    assertThat(binarySearchFloor(array, target, /* inclusive= */ false, /* stayInBounds= */ false))
+                /* value= */ 0,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
         .isEqualTo(-1);
-    assertThat(binarySearchFloor(array, target, /* inclusive= */ false, /* stayInBounds= */ true))
+  }
+
+  @Test
+  public void arrayBinarySearchFloor_targetSmallerThanValuesAndStayInBoundsTrue_returns0() {
+    assertThat(
+            binarySearchFloor(
+                new int[] {1, 3, 5},
+                /* value= */ 0,
+                /* inclusive= */ false,
+                /* stayInBounds= */ true))
         .isEqualTo(0);
   }
 
   @Test
-  public void testArrayBinarySearchFloor_targetBiggerThanArrayValues() {
+  public void arrayBinarySearchFloor_targetBiggerThanValues_returnsLastIndex() {
-    long[] array = new long[] {1, 3, 5};
+    assertThat(
-    int target = 6;
+            binarySearchFloor(
-
+                new int[] {1, 3, 5},
-    assertThat(binarySearchFloor(array, target, /* inclusive= */ false, /* stayInBounds= */ false))
+                /* value= */ 6,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
         .isEqualTo(2);
   }
 
   @Test
-  public void testArrayBinarySearchFloor_targetInArray() {
+  public void
-    long[] array = new long[] {1, 1, 1, 1, 1, 3, 5};
+      arrayBinarySearchFloor_targetEqualToFirstValueAndInclusiveFalseAndStayInBoundsFalse_returnsMinus1() {
-    int target = 1;
+    assertThat(
-
+            binarySearchFloor(
-    assertThat(binarySearchFloor(array, target, /* inclusive= */ false, /* stayInBounds= */ false))
+                new int[] {1, 1, 1, 1, 1, 3, 5},
+                /* value= */ 1,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
         .isEqualTo(-1);
-    assertThat(binarySearchFloor(array, target, /* inclusive= */ false, /* stayInBounds= */ true))
+  }
-        .isEqualTo(0);
+
-    assertThat(binarySearchFloor(array, target, /* inclusive= */ true, /* stayInBounds= */ false))
+  @Test
+  public void
+      arrayBinarySearchFloor_targetEqualToFirstValueAndInclusiveFalseAndStayInBoundsTrue_returns0() {
+    assertThat(
+            binarySearchFloor(
+                new int[] {1, 1, 1, 1, 1, 3, 5},
+                /* value= */ 1,
+                /* inclusive= */ false,
+                /* stayInBounds= */ true))
         .isEqualTo(0);
   }
 
   @Test
-  public void testArrayBinarySearchFloor_targetBetweenArrayValues() {
+  public void
-    long[] array = new long[] {1, 1, 1, 1, 1, 3, 5};
+      arrayBinarySearchFloor_targetInArrayAndInclusiveTrue_returnsFirstIndexWithValueEqualToTarget() {
-    int target = 2;
+    assertThat(
+            binarySearchFloor(
+                new int[] {1, 1, 1, 1, 1, 3, 5},
+                /* value= */ 1,
+                /* inclusive= */ true,
+                /* stayInBounds= */ false))
+        .isEqualTo(0);
+  }
 
-    assertThat(binarySearchFloor(array, target, /* inclusive= */ false, /* stayInBounds= */ false))
+  @Test
-        .isEqualTo(4);
+  public void
-    assertThat(binarySearchFloor(array, target, /* inclusive= */ true, /* stayInBounds= */ false))
+      arrayBinarySearchFloor_targetBetweenValuesAndInclusiveFalse_returnsIndexWhereTargetShouldBeInserted() {
+    assertThat(
+            binarySearchFloor(
+                new int[] {1, 1, 1, 1, 1, 3, 5},
+                /* value= */ 2,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
         .isEqualTo(4);
   }
 
   @Test
-  public void testListBinarySearchFloor_emptyList() {
+  public void
-    List<Integer> list = Arrays.asList(1, 3, 5);
+      arrayBinarySearchFloor_targetBetweenValuesAndInclusiveTrue_returnsIndexWhereTargetShouldBeInserted() {
-    int target = 0;
+    assertThat(
+            binarySearchFloor(
+                new int[] {1, 1, 1, 1, 1, 3, 5},
+                /* value= */ 2,
+                /* inclusive= */ true,
+                /* stayInBounds= */ false))
+        .isEqualTo(4);
+  }
 
-    assertThat(binarySearchFloor(list, target, /* inclusive= */ false, /* stayInBounds= */ false))
+  @Test
+  public void longArrayBinarySearchFloor_emptyArrayAndStayInBoundsFalse_returnsMinus1() {
+    assertThat(
+            binarySearchFloor(
+                new LongArray(), /* value= */ 0, /* inclusive= */ false, /* stayInBounds= */ false))
         .isEqualTo(-1);
-    assertThat(binarySearchFloor(list, target, /* inclusive= */ false, /* stayInBounds= */ true))
+  }
+
+  @Test
+  public void longArrayBinarySearchFloor_emptyArrayAndStayInBoundsTrue_returns0() {
+    assertThat(
+            binarySearchFloor(
+                new LongArray(), /* value= */ 0, /* inclusive= */ false, /* stayInBounds= */ true))
         .isEqualTo(0);
   }
 
   @Test
-  public void testListBinarySearchFloor_targetSmallerThanListValues() {
+  public void
-    List<Integer> list = Arrays.asList(1, 3, 5);
+      longArrayBinarySearchFloor_targetSmallerThanValuesAndStayInBoundsFalse_returnsMinus1() {
-    int target = 0;
+    LongArray longArray = new LongArray();
+    longArray.add(1);
+    longArray.add(3);
+    longArray.add(5);
 
-    assertThat(binarySearchFloor(list, target, /* inclusive= */ false, /* stayInBounds= */ false))
+    assertThat(
+            binarySearchFloor(
+                longArray, /* value= */ 0, /* inclusive= */ false, /* stayInBounds= */ false))
         .isEqualTo(-1);
-    assertThat(binarySearchFloor(list, target, /* inclusive= */ false, /* stayInBounds= */ true))
+  }
+
+  @Test
+  public void longArrayBinarySearchFloor_targetSmallerThanValuesAndStayInBoundsTrue_returns0() {
+    LongArray longArray = new LongArray();
+    longArray.add(1);
+    longArray.add(3);
+    longArray.add(5);
+
+    assertThat(
+            binarySearchFloor(
+                longArray, /* value= */ 0, /* inclusive= */ false, /* stayInBounds= */ true))
         .isEqualTo(0);
   }
 
   @Test
-  public void testListBinarySearchFloor_targetBiggerThanListValues() {
+  public void longArrayBinarySearchFloor_targetBiggerThanValues_returnsLastIndex() {
-    List<Integer> list = Arrays.asList(1, 3, 5);
+    LongArray longArray = new LongArray();
-    int target = 6;
+    longArray.add(1);
+    longArray.add(3);
+    longArray.add(5);
 
-    assertThat(binarySearchFloor(list, target, /* inclusive= */ false, /* stayInBounds= */ false))
+    assertThat(
+            binarySearchFloor(
+                longArray, /* value= */ 6, /* inclusive= */ false, /* stayInBounds= */ false))
         .isEqualTo(2);
   }
 
   @Test
-  public void testListBinarySearchFloor_targetInList() {
+  public void
-    List<Integer> list = Arrays.asList(1, 1, 1, 1, 1, 3, 5);
+      longArrayBinarySearchFloor_targetEqualToFirstValueAndInclusiveFalseAndStayInBoundsFalse_returnsMinus1() {
-    int target = 1;
+    LongArray longArray = new LongArray();
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(3);
+    longArray.add(5);
 
-    assertThat(binarySearchFloor(list, target, /* inclusive= */ false, /* stayInBounds= */ false))
+    assertThat(
-        .isEqualTo(-1);
+            binarySearchFloor(
-    assertThat(binarySearchFloor(list, target, /* inclusive= */ false, /* stayInBounds= */ true))
+                longArray, /* value= */ 1, /* inclusive= */ false, /* stayInBounds= */ false))
-        .isEqualTo(0);
-    assertThat(binarySearchFloor(list, target, /* inclusive= */ true, /* stayInBounds= */ false))
-        .isEqualTo(0);
-  }
-
-  @Test
-  public void testListBinarySearchFloor_targetBetweenListValues() {
-    List<Integer> list = Arrays.asList(1, 1, 1, 1, 1, 3, 5);
-    int target = 2;
-
-    assertThat(binarySearchFloor(list, target, /* inclusive= */ false, /* stayInBounds= */ false))
-        .isEqualTo(4);
-    assertThat(binarySearchFloor(list, target, /* inclusive= */ true, /* stayInBounds= */ false))
-        .isEqualTo(4);
-  }
-
-  @Test
-  public void testArrayBinarySearchCeil_emptyArray() {
-    long[] array = new long[0];
-    int target = 0;
-
-    assertThat(binarySearchCeil(array, target, /* inclusive= */ false, /* stayInBounds= */ false))
-        .isEqualTo(0);
-    assertThat(binarySearchCeil(array, target, /* inclusive= */ false, /* stayInBounds= */ true))
         .isEqualTo(-1);
   }
 
   @Test
-  public void testArrayBinarySearchCeil_targetSmallerThanArrayValues() {
+  public void
-    long[] array = new long[] {1, 3, 5};
+      longArrayBinarySearchFloor_targetEqualToFirstValueAndInclusiveFalseAndStayInBoundsTrue_returns0() {
-    int target = 0;
+    LongArray longArray = new LongArray();
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(3);
+    longArray.add(5);
 
-    assertThat(binarySearchCeil(array, target, /* inclusive= */ false, /* stayInBounds= */ false))
+    assertThat(
+            binarySearchFloor(
+                longArray, /* value= */ 1, /* inclusive= */ false, /* stayInBounds= */ true))
         .isEqualTo(0);
   }
 
   @Test
-  public void testArrayBinarySearchCeil_targetBiggerThanArrayValues() {
+  public void
-    long[] array = new long[] {1, 3, 5};
+      longArrayBinarySearchFloor_targetInArrayAndInclusiveTrue_returnsFirstIndexWithValueEqualToTarget() {
-    int target = 6;
+    LongArray longArray = new LongArray();
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(3);
+    longArray.add(5);
 
-    assertThat(binarySearchCeil(array, target, /* inclusive= */ false, /* stayInBounds= */ false))
+    assertThat(
+            binarySearchFloor(
+                longArray, /* value= */ 1, /* inclusive= */ true, /* stayInBounds= */ false))
+        .isEqualTo(0);
+  }
+
+  @Test
+  public void
+      longArrayBinarySearchFloor_targetBetweenValuesAndInclusiveFalse_returnsIndexWhereTargetShouldBeInserted() {
+    LongArray longArray = new LongArray();
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(3);
+    longArray.add(5);
+
+    assertThat(
+            binarySearchFloor(
+                longArray, /* value= */ 2, /* inclusive= */ false, /* stayInBounds= */ false))
+        .isEqualTo(4);
+  }
+
+  @Test
+  public void
+      longArrayBinarySearchFloor_targetBetweenValuesAndInclusiveTrue_returnsIndexWhereTargetShouldBeInserted() {
+    LongArray longArray = new LongArray();
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(1);
+    longArray.add(3);
+    longArray.add(5);
+
+    assertThat(
+            binarySearchFloor(
+                longArray, /* value= */ 2, /* inclusive= */ true, /* stayInBounds= */ false))
+        .isEqualTo(4);
+  }
+
+  @Test
+  public void listBinarySearchFloor_emptyListAndStayInBoundsFalse_returnsMinus1() {
+    assertThat(
+            binarySearchFloor(
+                new ArrayList<>(),
+                /* value= */ 0,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
+        .isEqualTo(-1);
+  }
+
+  @Test
+  public void listBinarySearchFloor_emptyListAndStayInBoundsTrue_returns0() {
+    assertThat(
+            binarySearchFloor(
+                new ArrayList<>(),
+                /* value= */ 0,
+                /* inclusive= */ false,
+                /* stayInBounds= */ true))
+        .isEqualTo(0);
+  }
+
+  @Test
+  public void listBinarySearchFloor_targetSmallerThanValuesAndStayInBoundsFalse_returnsMinus1() {
+    assertThat(
+            binarySearchFloor(
+                Arrays.asList(1, 3, 5),
+                /* value= */ 0,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
+        .isEqualTo(-1);
+  }
+
+  @Test
+  public void listBinarySearchFloor_targetSmallerThanValuesAndStayInBoundsTrue_returns0() {
+    assertThat(
+            binarySearchFloor(
+                Arrays.asList(1, 3, 5),
+                /* value= */ 0,
+                /* inclusive= */ false,
+                /* stayInBounds= */ true))
+        .isEqualTo(0);
+  }
+
+  @Test
+  public void listBinarySearchFloor_targetBiggerThanValues_returnsLastIndex() {
+    assertThat(
+            binarySearchFloor(
+                Arrays.asList(1, 3, 5),
+                /* value= */ 6,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
+        .isEqualTo(2);
+  }
+
+  @Test
+  public void
+      listBinarySearchFloor_targetEqualToFirstValueAndInclusiveFalseAndStayInBoundsFalse_returnsMinus1() {
+    assertThat(
+            binarySearchFloor(
+                Arrays.asList(1, 1, 1, 1, 1, 3, 5),
+                /* value= */ 1,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
+        .isEqualTo(-1);
+  }
+
+  @Test
+  public void
+      listBinarySearchFloor_targetEqualToFirstValueAndInclusiveFalseAndStayInBoundsTrue_returns0() {
+    assertThat(
+            binarySearchFloor(
+                Arrays.asList(1, 1, 1, 1, 1, 3, 5),
+                /* value= */ 1,
+                /* inclusive= */ false,
+                /* stayInBounds= */ true))
+        .isEqualTo(0);
+  }
+
+  @Test
+  public void
+      listBinarySearchFloor_targetInListAndInclusiveTrue_returnsFirstIndexWithValueEqualToTarget() {
+    assertThat(
+            binarySearchFloor(
+                Arrays.asList(1, 1, 1, 1, 1, 3, 5),
+                /* value= */ 1,
+                /* inclusive= */ true,
+                /* stayInBounds= */ false))
+        .isEqualTo(0);
+  }
+
+  @Test
+  public void
+      listBinarySearchFloor_targetBetweenValuesAndInclusiveFalse_returnsIndexWhereTargetShouldBeInserted() {
+    assertThat(
+            binarySearchFloor(
+                Arrays.asList(1, 1, 1, 1, 1, 3, 5),
+                /* value= */ 2,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
+        .isEqualTo(4);
+  }
+
+  @Test
+  public void
+      listBinarySearchFloor_targetBetweenValuesAndInclusiveTrue_returnsIndexWhereTargetShouldBeInserted() {
+    assertThat(
+            binarySearchFloor(
+                Arrays.asList(1, 1, 1, 1, 1, 3, 5),
+                /* value= */ 2,
+                /* inclusive= */ true,
+                /* stayInBounds= */ false))
+        .isEqualTo(4);
+  }
+
+  @Test
+  public void arrayBinarySearchCeil_emptyArrayAndStayInBoundsFalse_returns0() {
+    assertThat(
+            binarySearchCeil(
+                new int[0], /* value= */ 0, /* inclusive= */ false, /* stayInBounds= */ false))
+        .isEqualTo(0);
+  }
+
+  @Test
+  public void arrayBinarySearchCeil_emptyArrayAndStayInBoundsTrue_returnsMinus1() {
+    assertThat(
+            binarySearchCeil(
+                new int[0], /* value= */ 0, /* inclusive= */ false, /* stayInBounds= */ true))
+        .isEqualTo(-1);
+  }
+
+  @Test
+  public void arrayBinarySearchCeil_targetSmallerThanValues_returns0() {
+    assertThat(
+            binarySearchCeil(
+                new int[] {1, 3, 5},
+                /* value= */ 0,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
+        .isEqualTo(0);
+  }
+
+  @Test
+  public void arrayBinarySearchCeil_targetBiggerThanValuesAndStayInBoundsFalse_returnsLength() {
+    assertThat(
+            binarySearchCeil(
+                new int[] {1, 3, 5},
+                /* value= */ 6,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
         .isEqualTo(3);
-    assertThat(binarySearchCeil(array, target, /* inclusive= */ false, /* stayInBounds= */ true))
+  }
+
+  @Test
+  public void arrayBinarySearchCeil_targetBiggerThanValuesAndStayInBoundsTrue_returnsLastIndex() {
+    assertThat(
+            binarySearchCeil(
+                new int[] {1, 3, 5},
+                /* value= */ 6,
+                /* inclusive= */ false,
+                /* stayInBounds= */ true))
         .isEqualTo(2);
   }
 
   @Test
-  public void testArrayBinarySearchCeil_targetInArray() {
+  public void
-    long[] array = new long[] {1, 3, 5, 5, 5, 5, 5};
+      arrayBinarySearchCeil_targetEqualToLastValueAndInclusiveFalseAndStayInBoundsFalse_returnsLength() {
-    int target = 5;
+    assertThat(
-
+            binarySearchCeil(
-    assertThat(binarySearchCeil(array, target, /* inclusive= */ false, /* stayInBounds= */ false))
+                new int[] {1, 3, 5, 5, 5, 5, 5},
+                /* value= */ 5,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
         .isEqualTo(7);
-    assertThat(binarySearchCeil(array, target, /* inclusive= */ false, /* stayInBounds= */ true))
+  }
-        .isEqualTo(6);
+
-    assertThat(binarySearchCeil(array, target, /* inclusive= */ true, /* stayInBounds= */ false))
+  @Test
+  public void
+      arrayBinarySearchCeil_targetEqualToLastValueAndInclusiveFalseAndStayInBoundsTrue_returnsLastIndex() {
+    assertThat(
+            binarySearchCeil(
+                new int[] {1, 3, 5, 5, 5, 5, 5},
+                /* value= */ 5,
+                /* inclusive= */ false,
+                /* stayInBounds= */ true))
         .isEqualTo(6);
   }
 
   @Test
-  public void testArrayBinarySearchCeil_targetBetweenArrayValues() {
+  public void
-    long[] array = new long[] {1, 3, 5, 5, 5, 5, 5};
+      arrayBinarySearchCeil_targetInArrayAndInclusiveTrue_returnsLastIndexWithValueEqualToTarget() {
-    int target = 4;
+    assertThat(
+            binarySearchCeil(
+                new int[] {1, 3, 5, 5, 5, 5, 5},
+                /* value= */ 5,
+                /* inclusive= */ true,
+                /* stayInBounds= */ false))
+        .isEqualTo(6);
+  }
 
-    assertThat(binarySearchCeil(array, target, /* inclusive= */ false, /* stayInBounds= */ false))
+  @Test
-        .isEqualTo(2);
+  public void
-    assertThat(binarySearchCeil(array, target, /* inclusive= */ true, /* stayInBounds= */ false))
+      arrayBinarySearchCeil_targetBetweenValuesAndInclusiveFalse_returnsIndexWhereTargetShouldBeInserted() {
+    assertThat(
+            binarySearchCeil(
+                new int[] {1, 3, 5, 5, 5, 5, 5},
+                /* value= */ 4,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
         .isEqualTo(2);
   }
 
   @Test
-  public void testListBinarySearchCeil_emptyList() {
+  public void
-    List<Integer> list = new ArrayList<>();
+      arrayBinarySearchCeil_targetBetweenValuesAndInclusiveTrue_returnsIndexWhereTargetShouldBeInserted() {
-    int target = 0;
+    assertThat(
+            binarySearchCeil(
+                new int[] {1, 3, 5, 5, 5, 5, 5},
+                /* value= */ 4,
+                /* inclusive= */ true,
+                /* stayInBounds= */ false))
+        .isEqualTo(2);
+  }
 
-    assertThat(binarySearchCeil(list, target, /* inclusive= */ false, /* stayInBounds= */ false))
+  @Test
+  public void listBinarySearchCeil_emptyListAndStayInBoundsFalse_returns0() {
+    assertThat(
+            binarySearchCeil(
+                new ArrayList<>(),
+                /* value= */ 0,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
         .isEqualTo(0);
-    assertThat(binarySearchCeil(list, target, /* inclusive= */ false, /* stayInBounds= */ true))
+  }
+
+  @Test
+  public void listBinarySearchCeil_emptyListAndStayInBoundsTrue_returnsMinus1() {
+    assertThat(
+            binarySearchCeil(
+                new ArrayList<>(),
+                /* value= */ 0,
+                /* inclusive= */ false,
+                /* stayInBounds= */ true))
         .isEqualTo(-1);
   }
 
   @Test
-  public void testListBinarySearchCeil_targetSmallerThanListValues() {
+  public void listBinarySearchCeil_targetSmallerThanValues_returns0() {
-    List<Integer> list = Arrays.asList(1, 3, 5);
+    assertThat(
-    int target = 0;
+            binarySearchCeil(
-
+                Arrays.asList(1, 3, 5),
-    assertThat(binarySearchCeil(list, target, /* inclusive= */ false, /* stayInBounds= */ false))
+                /* value= */ 0,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
         .isEqualTo(0);
   }
 
   @Test
-  public void testListBinarySearchCeil_targetBiggerThanListValues() {
+  public void listBinarySearchCeil_targetBiggerThanValuesAndStayInBoundsFalse_returnsLength() {
-    List<Integer> list = Arrays.asList(1, 3, 5);
+    assertThat(
-    int target = 6;
+            binarySearchCeil(
-
+                Arrays.asList(1, 3, 5),
-    assertThat(binarySearchCeil(list, target, /* inclusive= */ false, /* stayInBounds= */ false))
+                /* value= */ 6,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
         .isEqualTo(3);
-    assertThat(binarySearchCeil(list, target, /* inclusive= */ false, /* stayInBounds= */ true))
+  }
+
+  @Test
+  public void listBinarySearchCeil_targetBiggerThanValuesAndStayInBoundsTrue_returnsLastIndex() {
+    assertThat(
+            binarySearchCeil(
+                Arrays.asList(1, 3, 5),
+                /* value= */ 6,
+                /* inclusive= */ false,
+                /* stayInBounds= */ true))
         .isEqualTo(2);
   }
 
   @Test
-  public void testListBinarySearchCeil_targetInList() {
+  public void
-    List<Integer> list = Arrays.asList(1, 3, 5, 5, 5, 5, 5);
+      listBinarySearchCeil_targetEqualToLastValueAndInclusiveFalseAndStayInBoundsFalse_returnsLength() {
-    int target = 5;
+    assertThat(
-
+            binarySearchCeil(
-    assertThat(binarySearchCeil(list, target, /* inclusive= */ false, /* stayInBounds= */ false))
+                Arrays.asList(1, 3, 5, 5, 5, 5, 5),
+                /* value= */ 5,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
         .isEqualTo(7);
-    assertThat(binarySearchCeil(list, target, /* inclusive= */ false, /* stayInBounds= */ true))
+  }
-        .isEqualTo(6);
+
-    assertThat(binarySearchCeil(list, target, /* inclusive= */ true, /* stayInBounds= */ false))
+  @Test
+  public void
+      listBinarySearchCeil_targetEqualToLastValueAndInclusiveFalseAndStayInBoundsTrue_returnsLastIndex() {
+    assertThat(
+            binarySearchCeil(
+                Arrays.asList(1, 3, 5, 5, 5, 5, 5),
+                /* value= */ 5,
+                /* inclusive= */ false,
+                /* stayInBounds= */ true))
         .isEqualTo(6);
   }
 
   @Test
-  public void testListBinarySearchCeil_targetBetweenListValues() {
+  public void
-    List<Integer> list = Arrays.asList(1, 3, 5, 5, 5, 5, 5);
+      listBinarySearchCeil_targetInListAndInclusiveTrue_returnsLastIndexWithValueEqualToTarget() {
-    int target = 4;
+    assertThat(
+            binarySearchCeil(
+                Arrays.asList(1, 3, 5, 5, 5, 5, 5),
+                /* value= */ 5,
+                /* inclusive= */ true,
+                /* stayInBounds= */ false))
+        .isEqualTo(6);
+  }
 
-    assertThat(binarySearchCeil(list, target, /* inclusive= */ false, /* stayInBounds= */ false))
+  @Test
+  public void
+      listBinarySearchCeil_targetBetweenValuesAndInclusiveFalse_returnsIndexWhereTargetShouldBeInserted() {
+    assertThat(
+            binarySearchCeil(
+                Arrays.asList(1, 3, 5, 5, 5, 5, 5),
+                /* value= */ 4,
+                /* inclusive= */ false,
+                /* stayInBounds= */ false))
         .isEqualTo(2);
-    assertThat(binarySearchCeil(list, target, /* inclusive= */ true, /* stayInBounds= */ false))
+  }
+
+  @Test
+  public void
+      listBinarySearchCeil_targetBetweenValuesAndInclusiveTrue_returnsIndexWhereTargetShouldBeInserted() {
+    assertThat(
+            binarySearchCeil(
+                Arrays.asList(1, 3, 5, 5, 5, 5, 5),
+                /* value= */ 4,
+                /* inclusive= */ true,
+                /* stayInBounds= */ false))
         .isEqualTo(2);
   }