}

  public void testShort() {
    Sink sink = new Sink(4);
    sink.putShort((short) 0x0201);
    HashCode unused = sink.hash();
    sink.assertInvariants(2);
    sink.assertBytes(new byte[] {1, 2, 0, 0}); // padded with zeros
  }

  public void testInt() {
    Sink sink = new Sink(4);
    sink.putInt(0x04030201);
    HashCode unused = sink.hash();
    sink.assertInvariants(4);
    sink.assertBytes(new byte[] {1, 2, 3, 4});

   * Nearly all declarations in this class are package-private,
   * accessed directly by subclasses.
   *
   * Table entries are of class Cell; a variant of AtomicLong padded
   * to reduce cache contention on most processors. Padding is
   * overkill for most Atomics because they are usually irregularly
   * scattered in memory and thus don't interfere much with each

   *     which case the input string is always returned.
   * @param padChar the character to insert at the beginning of the result until the minimum length
   *     is reached
   * @return the padded string
   */
  public static String padStart(String string, int minLength, char padChar) {
    checkNotNull(string); // eager for GWT.
    if (string.length() >= minLength) {
      return string;
    }

   * Nearly all declarations in this class are package-private,
   * accessed directly by subclasses.
   *
   * Table entries are of class Cell; a variant of AtomicLong padded
   * to reduce cache contention on most processors. Padding is
   * overkill for most Atomics because they are usually irregularly
   * scattered in memory and thus don't interfere much with each

     * The constructor requires exact sizes, so we need to pad them manually.
     */
    @Test
    void testAvSingleHostCustomDataMachineIdConstructor_ShorterInputs() {
        // Prepare padded arrays
        byte[] customData = new byte[8];
        customData[0] = 0x01;
        customData[1] = 0x02;

        byte[] machineId = new byte[32];
        machineId[0] = 0x10;
        machineId[1] = 0x11;

	// This matches most other JSON generators.
	// See golang.org/issue/6384 and golang.org/issue/14135.
	// Like fmt %g, but the exponent cutoffs are different
	// and exponents themselves are not padded to two digits.
	abs := math.Abs(f)
	fmt := byte('f')
	if abs != 0 {
		if abs < 1e-6 || abs >= 1e21 {
			fmt = 'e'
		}
	}
	dst = strconv.AppendFloat(dst, f, fmt, -1, 64)
	if fmt == 'e' {

	f.err = ErrFieldTooLong
}

func (p *parser) parseOctal(b []byte) int64 {
	// Because unused fields are filled with NULs, we need
	// to skip leading NULs. Fields may also be padded with
	// spaces or NULs.
	// So we remove leading and trailing NULs and spaces to
	// be sure.
	b = bytes.Trim(b, " \x00")

	if len(b) == 0 {
		return 0
	}

            final ByteBuffer buffer = ByteBuffer.wrap(nonce);
            buffer.order(java.nio.ByteOrder.LITTLE_ENDIAN);
            buffer.putLong(counter);
            // Remaining bytes (if any) stay zero-padded
        }

        return nonce;
    }

    /**
     * Generate a secure random nonce for initial session setup.
     * This method can be used when enhanced randomness is required,

        // Set converter value first
        setConverter(response, 0);

        // Set number of entries
        setNumEntries(response, 1);

        // Write share name (13 bytes, null padded)
        byte[] nameBytes = shareName.getBytes(StandardCharsets.US_ASCII);
        System.arraycopy(nameBytes, 0, buffer, bufferIndex, Math.min(nameBytes.length, 13));
        bufferIndex += 14;

        request = new Smb2NegotiateRequest(mockConfig, 0);

        // When
        int size = request.size();

        // Then - Header (64) + Structure (36) + Dialects (4 * 2) = 108, padded to 8-byte boundary = 112
        assertEquals(112, size);
    }

    @Test
    @DisplayName("Should calculate size correctly with contexts")
    void testSizeWithContexts() throws Exception {
        // Given