*/
    public E getFirst() {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }
        return getFirstEntry().element;
    }

    /**
     * Returns the last element.
     *
     * @return the last element
     */
    public E getLast() {
        if (isEmpty()) {
            throw new NoSuchElementException();
        }
        return getLastEntry().element;
    }

    private static final ConcurrentMap<Class<?>, Map<String, MethodInfo>> METHOD_CACHE = new ConcurrentHashMap<>();

    // Cache for field lookups: Class -> FieldName -> Field
    private static final ConcurrentMap<Class<?>, Map<String, Field>> FIELD_CACHE = new ConcurrentHashMap<>();

    private final ConverterLookup lookup;
    private final ClassLoader loader;

    return new Stopwatch(ticker);
  }

  /**
   * Creates (and starts) a new stopwatch using {@link System#nanoTime} as its time source.
   *
   * @since 15.0
   */
  public static Stopwatch createStarted() {
    return new Stopwatch().start();
  }

  /**
   * Creates (and starts) a new stopwatch, using the specified time source.
   *
   * @since 15.0
   */

     */
    public static int copy(final byte[] in, final Writer out) {
        assertArgumentNotNull("in", in);
        assertArgumentNotNull("out", out);

        final Reader is = new InputStreamReader(new ByteArrayInputStream(in));
        return copyInternal(is, wrap(out));
    }

    /**
     * Copies from a byte array to a writer using the specified encoding.
     * <p>

        super(message, cause);
    }

    /**
     * Constructs a new exception with the specified detail message.
     *
     * @param message the detail message.
     */
    public ExecutionTimeoutException(final String message) {
        super(message);
    }

    /**
     * Constructs a new exception with the specified cause.
     *

     */
    public static FileOutputStream create(final File file) {
        assertArgumentNotNull("file", file);

        try {
            return new FileOutputStream(file);
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }
    }

    /**
     * Flushes the {@link OutputStream}.
     *
     * @param out the output stream
     */

        validateInputStream(in);
        try (final org.apache.poi.hwpf.extractor.WordExtractor wordExtractor = new org.apache.poi.hwpf.extractor.WordExtractor(in)) {
            return new ExtractData(wordExtractor.getText());
        } catch (final IOException e) {
            throw new ExtractException("Failed to extract text from Word document.", e);
        }
    }

  @Override
  public SampleElements<String> samples() {
    return new Strings();
  }

  @Override
  public List<String> create(Object... elements) {
    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  /**
   * Creates a new collection containing the given elements; implement this method instead of {@link

  @Override
  public SampleElements<Character> samples() {
    return new Chars();
  }

  @Override
  public List<Character> create(Object... elements) {
    Character[] array = new Character[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (Character) e;
    }
    return create(array);
  }

  /**

 */
@NullUnmarked
public class ForwardingListMultimapTest extends TestCase {

  @SuppressWarnings("rawtypes")
  public void testForwarding() {
    new ForwardingWrapperTester()
        .testForwarding(
            ListMultimap.class,
            new Function<ListMultimap, ListMultimap<?, ?>>() {
              @Override
              public ListMultimap<?, ?> apply(ListMultimap delegate) {