@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class ListGetTester<E> extends AbstractListTester<E> {
  public void testGet_valid() {
    // This calls get() on each index and checks the result:
    expectContents(createOrderedArray());
  }

  public void testGet_negative() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().get(-1));
  }

  public void testGet_tooLarge() {

     *
     * @return the artifact filter
     */
    ArtifactFilter getCoreArtifactFilter();

    /**
     * Exclude an extension artifact (doesn't affect getArtifactFilter's result, only getExtensionArtifactFilter).
     *
     * @param artifactId an artifact id
     * @deprecated use {@code META-INF/maven/extension.xml} to define artifacts exported by Maven core and plugin
     *             extensions.

            // Given
            byte[] dst = new byte[100];
            int dstIndex = 0;

            // When
            int result = response.writeBytesWireFormat(dst, dstIndex);

            // Then
            assertEquals(0, result);
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 10, 50, 99 })
        @DisplayName("Should return 0 regardless of destination index")

    }

    /**
     * Compares two SMB files by name.
     * @param f1 first file to compare
     * @param f1name name of first file
     * @param f2 second file to compare
     * @return comparison result for sorting
     * @throws IOException if an I/O error occurs
     */
    protected int compareNames(final SmbFile f1, final String f1name, final SmbFile f2) throws IOException {

      }
    }
    List<Class<?>> result = new ArrayList<>();
    NEXT_CANDIDATE:
    for (Class<?> candidate : Iterables.filter(candidateClasses, classFilter)) {
      for (Class<?> testClass : testClasses.get(candidate)) {
        if (hasTest(testClass, explicitTestNames)) {
          // covered by explicit test
          continue NEXT_CANDIDATE;
        }
      }
      result.add(candidate);
    }
    return result;

            return out.toByteArray();
          }
        };

    File asciiFile = getTestFile("ascii.txt");
    byte[] result = Files.readBytes(asciiFile, processor);
    assertEquals(Bytes.asList(Files.toByteArray(asciiFile)), Bytes.asList(result));
  }

  public void testReadBytes_returnFalse() throws IOException {
    ByteProcessor<byte[]> processor =
        new ByteProcessor<byte[]>() {

    V result = get(key);
    return (result != null) ? result : defaultValue;
  }

  V getOrLoad(K key) throws ExecutionException {
    return get(key, defaultLoader);
  }

  ImmutableMap<K, V> getAllPresent(Iterable<?> keys) {
    int hits = 0;
    int misses = 0;

    ImmutableMap.Builder<K, V> result = ImmutableMap.builder();
    for (Object key : keys) {

   */
  @Override
  int hashCode();

  /**
   * {@inheritDoc}
   *
   * <p>It is recommended, though not mandatory, that this method return the result of invoking
   * {@link #toString} on the {@link #entrySet}, yielding a result such as {@code [a x 3, c, d x 2,
   * e]}.
   */
  @Override
  String toString();

  // Refined Collection Methods

  /**
   * {@inheritDoc}
   *

package org.apache.maven.plugin.prefix.internal;

import org.apache.maven.model.Plugin;
import org.apache.maven.plugin.prefix.PluginPrefixResult;
import org.eclipse.aether.repository.ArtifactRepository;

/**
 * Describes the result of a plugin prefix resolution request.
 *
 * @since 3.0
 */
class DefaultPluginPrefixResult implements PluginPrefixResult {

    private String groupId;

    private String artifactId;

import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Indicates that the annotated bean has a lifespan limited to a given mojo execution,
 * which means each mojo execution will result in a different instance being injected.
 * <p>
 * The following objects will be bound to the mojo execution scope:
 *     <ul>
 *         <li>{@code org.apache.maven.api.MojoExecution}</li>