assertEquals(mockCredentials, wrapper.getCredentials(), "Initial credentials should be set by constructor");
    }

    @Test
    @DisplayName("Should return the credentials provided in the constructor")
    void testGetCredentials() {
        assertEquals(mockCredentials, wrapper.getCredentials(), "getCredentials should return the initially set credentials");
    }

    @Test

                        () -> asListHtml(this::saveToken));
            }
        }
        return redirect(getClass()); // no-op
    }

    /**
     * Creates a CURL request from the provided header string.
     *
     * @param header the header string containing HTTP method and path
     * @return CURL request object or null if header is invalid
     */

  @CanIgnoreReturnValue
  <T extends @Nullable Object> Hasher putObject(
      @ParametricNullness T instance, Funnel<? super T> funnel);

  /**
   * Computes a hash code based on the data that have been provided to this hasher. The result is
   * unspecified if this method is called more than once on the same instance.
   */
  HashCode hash();

  /**
   * {@inheritDoc}
   *

        setResult(result);
        setMechanism(mechanism);
        setMechanismToken(mechanismToken);
        setMechanismListMIC(mechanismListMIC);
    }

    /**
     * Constructs a NegTokenTarg by parsing the provided token bytes
     * @param token the SPNEGO token bytes to parse
     * @throws IOException if parsing fails
     */
    public NegTokenTarg(final byte[] token) throws IOException {
        parse(token);
    }

      R rowKey = cell.getRowKey();
      C columnKey = cell.getColumnKey();
      V value = cell.getValue();

      /*
       * These requireNonNull calls are safe because we construct the maps to hold all the provided
       * cells.
       */
      cellRowIndices[i] = requireNonNull(rowIndex.get(rowKey));
      Map<C, V> thisRow = requireNonNull(rows.get(rowKey));
      cellColumnInRowIndices[i] = thisRow.size();

    }

    /**
     * Clears all cached popular word lists.
     */
    public void clearCache() {
        cache.invalidateAll();
    }

    /**
     * Generates a cache key based on the provided parameters.
     *
     * @param seed the seed value
     * @param tags array of tags
     * @param roles array of roles
     * @param fields array of fields
     * @param excludes array of excluded words

     *         this version range, provided that ranges falls within the intersected restrictions. If
     *         the restrictions are empty, this version range's recommended version is used if it is not
     *         <code>null</code>. If it is <code>null</code>, the specified version range's recommended
     *         version is used (provided it is non-<code>null</code>). If no recommended version can be

@GwtCompatible
abstract class AbstractListMultimap<K extends @Nullable Object, V extends @Nullable Object>
    extends AbstractMapBasedMultimap<K, V> implements ListMultimap<K, V> {
  /**
   * Creates a new multimap that uses the provided map.
   *
   * @param map place to store the mapping from each key to its corresponding values
   */
  protected AbstractListMultimap(Map<K, Collection<V>> map) {
    super(map);
  }

  @Override

 * change the behavior of {@link #equals}, which can lead to unexpected behavior. In this case, you
 * should override {@code equals} as well, either providing your own implementation, or delegating
 * to the provided {@code standardEquals} method.
 *
 * <p>Each of the {@code standard} methods, where appropriate, use {@link Objects#equals} to test
 * equality for both keys and values. This may not be the desired behavior for map implementations

    checkArgument(min <= max, "min (%s) must be less than or equal to max (%s)", min, max);
    return Math.min(Math.max(value, min), max);
  }

  /**
   * Returns the values from each provided array combined into a single array. For example, {@code
   * concat(new int[] {a, b}, new int[] {}, new int[] {c}} returns the array {@code {a, b, c}}.
   *
   * @param arrays zero or more {@code int} arrays