private long mid;
        private int command;
        private int uid;
        private boolean extendedSecurity;
        private long sessionId;
        private boolean retainPayload;
        private byte[] rawPayload;

        // Response interface fields
        private boolean received = false;
        private int grantedCredits = 0;
        private int errorCode = 0;
        private boolean verifyFailed = false;

     */
    String getName();

    /**
     * Gets the type of the entry.
     *
     * @return the entry type
     */
    int getType();

    /**
     * Gets the file attributes.
     *
     * @return the file attributes
     */
    int getAttributes();

    /**
     * Gets the creation time.
     *
     * @return the creation time in milliseconds since epoch
     */

			tokens = b
		}
	} else { // all tokens go towards payload
		need = int(math.Min(float64(b), float64(need)))
		tokens = need
	}
	// reduce tokens requested according to availability
	av := int(r.throttle.Tokens())
	if av < tokens && av > 0 {
		tokens = av
		need = int(math.Min(float64(tokens), float64(need)))
	}
	err = r.throttle.WaitN(r.ctx, tokens)
	if err != nil {
		return n, err

            this.byteCount = bytes.length;
        }

        @Override
        int writeParameterWordsWireFormat(byte[] dst, int dstIndex) {
            System.arraycopy(paramWords, 0, dst, dstIndex, paramWords.length);
            return paramWords.length;
        }

        @Override
        int writeBytesWireFormat(byte[] dst, int dstIndex) {
            System.arraycopy(bytes, 0, dst, dstIndex, bytes.length);

   *
   * @return the sum
   */
  @Override
  public long longValue() {
    return sum();
  }

  /** Returns the {@link #sum} as an {@code int} after a narrowing primitive conversion. */
  @Override
  public int intValue() {
    return (int) sum();
  }

  /** Returns the {@link #sum} as a {@code float} after a widening primitive conversion. */
  @Override
  public float floatValue() {

    }

    @Test
    public void testVariousFieldValues() {
        int[][] testCases = { { 0, 0, 0 }, { 100, 200, 300 }, { 32767, 32767, 32767 }, { 65535, 65535, 65535 } };

        for (int[] testCase : testCases) {
            int serverType = testCase[0];
            int proximity = testCase[1];
            int ttl = testCase[2];

        }

        // Remove old versions
        int removed = 0;
        for (Map.Entry<String, java.util.List<String>> entry : sessionArchives.entrySet()) {
            java.util.List<String> archives = entry.getValue();

            // Sort by version number
            archives.sort((a, b) -> {
                int versionA = extractVersion(a);
                int versionB = extractVersion(b);

  public void testConcat_overflow_negative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 15;
    assertThat(dim1 * dim2).isLessThan(0);
    testConcatOverflow(dim1, dim2);
  }

  @GwtIncompatible // different overflow behavior; could probably be made to work by using ~~
  public void testConcat_overflow_nonNegative() {
    int dim1 = 1 << 16;
    int dim2 = 1 << 16;
    assertThat(dim1 * dim2).isAtLeast(0);

            @Override
            public int read() throws IOException {
                return originalStream.read();
            }

            @Override
            public int read(byte[] b) throws IOException {
                return originalStream.read(b);
            }

            @Override
            public int read(byte[] b, int off, int len) throws IOException {

    /** Transformer used to transform response data */
    protected Transformer transformer;

    /** HTTP status codes considered successful */
    protected int[] successfulHttpCodes;

    /** HTTP status codes considered not modified */
    protected int[] notModifiedHttpCodes;

    /**
     * Constructs a new DefaultResponseProcessor.
     */
    public DefaultResponseProcessor() {
        // Default constructor