public MapCacheTest(MapIteratorCache<String, String> mapCache) {
    this.mapCache = mapCache;
  }

  @Parameters
  public static Collection<Object[]> parameters() {
    Comparator<String> nullsLast = Ordering.natural().nullsLast();

    return Arrays.asList(
        new Object[][] {
          {new MapIteratorCache<String, String>(new HashMap<String, String>())},

  @Override
  public int compare(Comparable<?> left, Comparable<?> right) {
    checkNotNull(left); // right null is caught later
    if (left == right) {
      return 0;
    }

    return ((Comparable<Object>) right).compareTo(left);
  }

  @Override
  public <S extends Comparable<?>> Ordering<S> reverse() {
    return Ordering.natural();
  }

  // Override the min/max methods to "hoist" delegation outside loops

        }

        return artifactMap;
    }

    public boolean equals(Object object) {
        if (this == object) {
            return true;
        }

        return object instanceof PluginDescriptor && getId().equals(((PluginDescriptor) object).getId());
    }

    public int hashCode() {
        return 10 + getId().hashCode();
    }

        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        if (fessConfig.isFileRoleFromFile() && responseData.getUrl().startsWith("file:")) {
            final Map<String, Object> metaDataMap = responseData.getMetaDataMap();
            final Object fileAttributeView = metaDataMap.get(FileSystemClient.FILE_ATTRIBUTE_VIEW);
            try {
                if (fileAttributeView instanceof final AclFileAttributeView aclFileAttributeView) {

            conditionMap.put(key, regex);
        } else {
            conditionMap.put(key, value + "|" + regex);
        }
    }

    @Override
    public boolean isTarget(final Map<String, Object> docMap) {
        final String thumbnailFieldName = ComponentUtil.getFessConfig().getIndexFieldThumbnail();
        if (logger.isDebugEnabled()) {
            logger.debug("[{}] thumbnail: {}", name, docMap.get(thumbnailFieldName));

          exceptions.add(e)
        }
      }
    }

    fun takeException(): Exception {
      return exceptions.take()
    }
  }

  companion object {
    fun uppercase(original: ResponseBody): ResponseBody {
      return object : ResponseBody() {
        override fun contentType() = original.contentType()

        override fun contentLength() = original.contentLength()

    )
  }

  /** Repeat with a delay of 200 but schedule with a delay of 50. The schedule wins. */
  @Test fun executeScheduledEarlierReplacesRepeatedLater() {
    val task =
      object : Task("task") {
        val schedules = mutableListOf(50.µs)
        val delays = mutableListOf(200.µs, -1)

        override fun runOnce(): Long {
          log += "run@${taskFaker.nanoTime}"

                * Serialization: you could return an arbitrary object and the
                    `response_model` would be used to serialize that object into the
                    corresponding JSON.
                * Filtering: the JSON sent to the client will only contain the data
                    (fields) defined in the `response_model`. If you returned an object

  @Override
  public String toString() {
    return "Hashing.murmur3_32(" + seed + ")";
  }

  @Override
  public boolean equals(@CheckForNull Object object) {
    if (object instanceof Murmur3_32HashFunction) {
      Murmur3_32HashFunction other = (Murmur3_32HashFunction) object;
      return seed == other.seed && supplementaryPlaneFix == other.supplementaryPlaneFix;
    }
    return false;
  }

  @Override

  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "javaName"),
    level = DeprecationLevel.ERROR,
  )
  fun javaName(): String = javaName

  companion object {
    @JvmStatic
    fun forJavaName(javaName: String): TlsVersion {
      return when (javaName) {
        "TLSv1.3" -> TLS_1_3
        "TLSv1.2" -> TLS_1_2
        "TLSv1.1" -> TLS_1_1
        "TLSv1" -> TLS_1_0