@Override
    public SampleElements<Integer> samples() {
      return new SampleElements<>(1, 4, 3, 2, 5);
    }

    @Override
    public Integer[] createArray(int length) {
      return new Integer[length];
    }

    @Override
    public Iterable<Integer> order(List<Integer> insertionOrder) {

}

func genMessage(header, payload []byte) []byte {
	headerLength := len(header)
	payloadLength := len(payload)
	totalLength := totalByteLength(headerLength, payloadLength)

	buf := new(bytes.Buffer)
	binary.Write(buf, binary.BigEndian, uint32(totalLength))
	binary.Write(buf, binary.BigEndian, uint32(headerLength))
	prelude := buf.Bytes()
	binary.Write(buf, binary.BigEndian, crc32.ChecksumIEEE(prelude))

 * methods to access and modify them.
 * </p>
 *
 * <p>
 * Example usage:
 * </p>
 * <pre>
 * {@code
 * AuthScope authScope = new AuthScope("example.com", 80);
 * Credentials credentials = new UsernamePasswordCredentials("user", "password");
 * AuthenticationImpl auth = new AuthenticationImpl(authScope, credentials);
 * }
 * </pre>
 *
 * @see org.codelibs.fess.crawler.client.http.Authentication
 */

@NullUnmarked
public abstract class AbstractChainedListenableFutureTest<T> extends TestCase {
  protected static final int EXCEPTION_DATA = -1;
  protected static final int VALID_INPUT_DATA = 1;
  protected static final Exception EXCEPTION = new Exception("Test exception");

  protected SettableFuture<Integer> inputFuture;
  protected ListenableFuture<T> resultFuture;
  protected MockFutureListener listener;

  @Override

    }

    @Override
    public void storeInLocalRepository(ArtifactRepository localRepository, ArtifactRepository remoteRepository)
            throws RepositoryMetadataStoreException {
        File destination = new File(
                localRepository.getBasedir(), localRepository.pathOfLocalRepositoryMetadata(this, remoteRepository));

        // ----------------------------------------------------------------------------

  }

  @CanIgnoreReturnValue
  private File newDir(String name) {
    File file = new File(rootDir, name);
    file.mkdir();
    return file;
  }

  @CanIgnoreReturnValue
  private File newFile(String name) throws IOException {
    File file = new File(rootDir, name);
    file.createNewFile();
    return file;
  }

        TransferResource resource = event.getResource();
        long contentLength = event.getTransferredBytes();
        FileSizeFormat format = new FileSizeFormat();

        StringBuilder message = new StringBuilder();
        message.append(action).append(' ').append(direction).append(' ').append(resource.getRepositoryId());
        message.append(": ");

                System.out.println("Arg: '" + a + "'");
            }
            throw e;
        }
    }

    private static String[] doCleanArgs(String[] args) {
        List<String> cleaned = new ArrayList<>();

        StringBuilder currentArg = null;

        for (String arg : args) {
            boolean addedToBuffer = false;

            if (arg.startsWith("\"")) {

      return Math.min(Math.max(value, min), max);
    }
    throw new IllegalArgumentException(
        lenientFormat("min (%s) must be less than or equal to max (%s)", min, max));
  }

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

    }

    Sub2Interface getSomeProp() {
        // ignore classes in method bodies
        class IgnoreMe {}

        // ignore anonymous classes
        return new Sub2Interface() { };
    }

    // ignore anonymous classes
    final Runnable ignoreMe = new Runnable() {
        public void run() {
        }
    };

    InnerClass.AnotherInner getInnerClassProp() { return null; }