RangeMap<Integer, Integer> rangeMap = TreeRangeMap.create();
      rangeMap.put(range, 1);

      try {
        assertEquals(range, rangeMap.span());
        assertFalse(range.isEmpty());
      } catch (NoSuchElementException e) {
        assertTrue(range.isEmpty());
      }
    }
  }

  public void testSpanTwoRanges() {
    for (Range<Integer> range1 : RANGES) {

   */
  static boolean safeContains(Collection<?> collection, @Nullable Object object) {
    checkNotNull(collection);
    try {
      return collection.contains(object);
    } catch (ClassCastException | NullPointerException e) {
      return false;
    }
  }

  /**
   * Delegates to {@link Collection#remove}. Returns {@code false} if the {@code remove} method

                        list = new ArrayList<>();
                        paramListMap.put(key, list);
                    }
                    list.add(StringUtil.EMPTY);
                }
            }
        } catch (final DecoderException e) {
            throw new IOException(e);
        }

        final Map<String, String[]> paramMap = new HashMap<>(paramListMap.size());

                } else if (logger.isDebugEnabled()) {
                    logger.debug("No KeyMatch boost docs");
                }

                waitForNext();
            } catch (final Exception e) {
                logger.warn("Failed to load KeyMatch: id={}, term={}", keyMatch.getId(), keyMatch.getTerm(), e);
            }
        });
        this.keyMatchQueryMap = keyMatchQueryMap;

            return null;
        });
        try (InputStream inputStream = form.stemmerOverrideFile.getInputStream()) {
            file.update(inputStream);
        } catch (final IOException e) {
            logger.warn("Failed to process a request.", e);
            throwValidationErrorApi(messages -> messages.addErrorsFailedToUploadProtwordsFile(GLOBAL));
        }

            result.setUserAgent(DfTypeUtil.toString(source.get("userAgent")));
            result.setVirtualHosts(toStringArray(source.get("virtualHosts")));
            return updateEntity(source, result);
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    serverSocket!!.reuseAddress = false
    serverSocket!!.bind(InetSocketAddress("localhost", 0), 1)
    port = serverSocket!!.localPort
    executor.execute {
      try {
        readAndWriteFrames()
      } catch (e: IOException) {
        ******@****.***uietly()
        logger.info("${this@MockHttp2Peer} done: ${e.message}")
      }
    }
  }

  private fun readAndWriteFrames() {
    check(socket == null)

                        int written = req.writeBytesWireFormat(buffer, 0);
                        success[index] = (written == 4 && SMBUtil.readInt2(buffer, 0) == 4);
                    } catch (Exception e) {
                        success[index] = false;
                    }
                });
                threads[i].start();
            }

            for (Thread thread : threads) {

                    }
                } else {
                    context.success("No inference optimizations needed");
                }
            } catch (Exception e) {
                context.failure("Failed to apply inference optimizations" + ": " + e.getMessage());
                errorPoms.add(pomPath);
            } finally {
                context.unindent();

      it is Canceled ||
      it is RequestFailed ||
      it is ResponseFailed

  private fun sleep(delayMillis: Int) {
    try {
      Thread.sleep(delayMillis.toLong())
    } catch (e: InterruptedException) {
      Thread.currentThread().interrupt()
    }
  }

  private fun cancelLater(
    call: Call,
    delayMillis: Int,
  ): CountDownLatch {
    val latch = CountDownLatch(1)