for (int i = 0; i < 150; i++) {
            largeParams.put("key" + i, "value" + i);
        }

        assertNotNull(queryRescorer.evaluate(largeParams));

        // Test with small number of parameters
        Map<String, Object> smallParams = new HashMap<>();
        smallParams.put("key", "value");
        assertNull(queryRescorer.evaluate(smallParams));
    }

  public void testPut_supportedPresent() {
    assertEquals("put(present, value) should return the old value", v0(), getMap().put(k0(), v3()));
    expectReplacement(entry(k0(), v3()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPut_supportedNotPresent() {
    assertNull("put(notPresent, value) should return null", put(e3()));
    expectAdded(e3());
  }

  public void testReturning() throws Exception {
    assertNull(Callables.returning(null).call());

    Object value = new Object();
    Callable<Object> callable = Callables.returning(value);
    assertSame(value, callable.call());
    // Expect the same value on subsequent calls
    assertSame(value, callable.call());
  }

  @J2ktIncompatible
  @GwtIncompatible
  public void testAsAsyncCallable() throws Exception {

     * @param value the original value to process
     * @param template the template script to evaluate
     * @param scriptType the type of script engine to use
     */
    default void putResultDataWithTemplate(final Map<String, Object> dataMap, final String key, final Object value, final String template,
            final String scriptType) {
        Object target = value;
        if (template != null) {

    }
  }

  private static final class Collider {
    final int value;

    Collider(int value) {
      this.value = value;
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      return obj instanceof Collider && ((Collider) obj).value == value;
    }

    @Override
    public int hashCode() {
      return 1; // evil!
    }
  }

var v *T           // v has value nil, static type *T
x = 42             // x has value 42 and dynamic type int
x = v              // x has value (*T)(nil) and dynamic type *T
</pre>

<p>
A variable's value is retrieved by referring to the variable in an
<a href="#Expressions">expression</a>; it is the most recent value
<a href="#Assignment_statements">assigned</a> to the variable.

                "Unknown q: " + query.getClass() + " => " + query);
    }

    /**
     * Converts a TermQuery to a QueryBuilder with the given boost value.
     *
     * @param context the query context
     * @param termQuery the term query to convert
     * @param boost the boost value to apply
     * @return the converted QueryBuilder
     */

   */
  ImmutableMap<K, V> getAllPresent(Iterable<? extends Object> keys);

  /**
   * Associates {@code value} with {@code key} in this cache. If the cache previously contained a
   * value associated with {@code key}, the old value is replaced by {@code value}.
   *
   * <p>Prefer {@link #get(Object, Callable)} when using the conventional "if cached, return;
   * otherwise create, cache and return" pattern.

   * also becomes a successor. Associates {@code value} with the edge connecting the two nodes.
   */
  void addPredecessor(N node, V value);

  /**
   * Add {@code node} as a successor to the origin node. In the case of an undirected graph, it also
   * becomes a predecessor. Associates {@code value} with the edge connecting the two nodes. Returns
   * the value previously associated with the edge connecting the two nodes.
   */

  }

  /** Returns a PublicSuffixType of the right type according to the given code */
  static PublicSuffixType fromCode(char code) {
    for (PublicSuffixType value : values()) {
      if (value.getInnerNodeCode() == code || value.getLeafNodeCode() == code) {
        return value;
      }
    }
    throw new IllegalArgumentException("No enum corresponding to given code: " + code);
  }