static <T extends Throwable> T assertThrows(
      Class<T> expectedThrowable, ThrowingRunnable runnable) {
    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {

  static <T extends Throwable> T assertThrows(
      Class<T> expectedThrowable, ThrowingRunnable runnable) {
    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {

  static <T extends Throwable> T assertThrows(
      Class<T> expectedThrowable, ThrowingRunnable runnable) {
    return doAssertThrows(
        expectedThrowable,
        () -> {
          runnable.run();
          return null;
        },
        /* userPassedSupplier= */ false);
  }

  private static <T extends Throwable> T doAssertThrows(
      Class<T> expectedThrowable, ThrowingSupplier supplier, boolean userPassedSupplier) {

    BufferedReader r = new BufferedReader(getChunkedReader(input, chunk));
    List<String> lines = Lists.newArrayList();
    String line;
    while ((line = r.readLine()) != null) {
      lines.add(line);
    }
    r.close();
    return lines;
  }

  private static List<String> readUsingReader(String input, int chunk, boolean asReader)
      throws IOException {

    }
    N previousNode = inEdgeMap.put(edge, node);
    checkState(previousNode == null);
  }

  @Override
  public void addOutEdge(E edge, N node) {
    checkNotNull(edge);
    checkNotNull(node);

    N previousNode = outEdgeMap.put(edge, node);
    checkState(previousNode == null);
  }

                if (path.endsWith("mapping.txt")) {
                    logger.debug("Updating {}", path);
                    final String content = getDictionaryContent(path);
                    if (content != null) {
                        sendDictionaryContent(path, StreamUtil.split(content, "\n")
                                .get(stream -> stream.map(s -> s.replaceFirst("#.*", StringUtil.EMPTY)).collect(Collectors.joining("\n"))));

 * limitations under the License.
 */

package gradlebuild.binarycompatibility

import japicmp.util.Optional


internal

            Cut.belowValue(key),
            KeyPresentBehavior.ANY_PRESENT,
            KeyAbsentBehavior.NEXT_LOWER);
    if (index == -1) {
      return null;
    } else {
      Range<K> range = ranges.get(index);
      return range.contains(key) ? values.get(index) : null;
    }
  }

  @Override
  @CheckForNull
  public Entry<Range<K>, V> getEntry(K key) {
    int index =
        SortedLists.binarySearch(

  }

  @SuppressWarnings("ReturnValueIgnored")
  public void testMaximumWeight_withoutWeigher() {
    CacheBuilder<Object, Object> builder = CacheBuilder.from(parse("maximumWeight=9000"));
    assertThrows(
        IllegalStateException.class,
        () -> builder.build(CacheLoader.from(Suppliers.ofInstance(null))));
  }

  @SuppressWarnings("ReturnValueIgnored")

   *
   * @param value value to search for
   */
  boolean containsValue(@CompatibleWith("V") @CheckForNull Object value);

  /**
   * Returns the value corresponding to the given row and column keys, or {@code null} if no such
   * mapping exists.
   *
   * @param rowKey key of row to search for
   * @param columnKey key of column to search for
   */
  @CheckForNull
  V get(