assertTrue(result.contains("nextEntry="));
        assertTrue(result.contains("action="));
        assertTrue(result.contains("file=" + fileName));
        // Hexdump.toHexString produces 4-character padded uppercase hex
        String expectedHex = String.format("%04X", action);
        assertTrue(result.contains("0x" + expectedHex));
    }

    @Test
    @DisplayName("Test toString with empty object")

   *     which case the input string is always returned.
   * @param padChar the character to append to the end of the result until the minimum length is
   *     reached
   * @return the padded string
   */
  public static String padEnd(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

            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,

        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

        // 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;

        byte[] buffer = new byte[totalSize + 100];
        int bufferIndex = 0;
        int start = 0;

        // Write server name (16 bytes, null padded)
        byte[] nameBytes = serverName.getBytes(StandardCharsets.US_ASCII);
        System.arraycopy(nameBytes, 0, buffer, bufferIndex, Math.min(nameBytes.length, 15));
        bufferIndex += 16;

	// Also, future updates to AWS might require larger sizes.
	Credentials auth.Credentials `xml:",omitempty"`

	// A percentage value that indicates the size of the policy in packed form.
	// The service rejects any policy with a packed size greater than 100 percent,
	// which means the policy exceeded the allowed space.
	PackedPolicySize int `xml:",omitempty"`
}

    /**
     * Parses the given query string and returns a Lucene Query object.
     * The query is processed through the filter chain before being parsed.
     *
     * @param query the query string to parse
     * @return the parsed Query object
     * @throws QueryParseException if the query cannot be parsed
     */
    public Query parse(final String query) {
        return filterChain.parse(query);
    }

    /**

        /** The writer for the temporary file. */
        protected Writer writer;

        /** The stopword item being added or updated. */
        protected StopwordsItem item;

        /**
         * Constructs a new updater for a stopword item.
         *
         * @param newItem The item to be added or updated.
         * @throws DictionaryException if the temporary file cannot be created.
         */