/**
     * Associates {@code key} with {@code value} in the built map. If the same key is put more than
     * once, {@link #buildOrThrow} will fail, while {@link #buildKeepingLast} will keep the last
     * value put for that key.
     */
    @CanIgnoreReturnValue
    public Builder<K, V> put(K key, V value) {
      ensureCapacity(size + 1);
      Entry<K, V> entry = entryOf(key, value);

        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));
    }

    /**
     * The name identifier for the annotated element.
     * <p>
     * If no value is specified, the default empty string will be used.
     * When used as a qualifier, this value helps distinguish between different
     * implementations or instances of the same type.
     *
     * @return the name that identifies this component
     */
    String value() default "";

   * 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.
   */

            String key = (String) provide.getKey();
            String value = (String) provide.getValue();

            if (value == null) {
                throw new MisconfiguredToolchainException(
                        "Provides token '" + key + "' doesn't have any value configured.");
            }

            RequirementMatcher matcher;
            if ("version".equals(key)) {

     * @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) {

  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 {

   */
  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.

 */
class SMBUtilTest {

    @Test
    void testWriteInt2() {
        byte[] dst = new byte[10];

        // Test with simple value
        SMBUtil.writeInt2(0x1234L, dst, 0);
        assertEquals((byte) 0x34, dst[0]);
        assertEquals((byte) 0x12, dst[1]);

        // Test with max value for 2 bytes
        SMBUtil.writeInt2(0xFFFFL, dst, 2);
        assertEquals((byte) 0xFF, dst[2]);
        assertEquals((byte) 0xFF, dst[3]);

  }

  /** 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);
  }