heap dumps # generate a heap dump when an allocation from the Java heap fails # heap dumps are created in the working directory of the JVM -XX:+HeapDumpOnOutOfMemor # specify an alternative path for heap dumps; ensure the directory exists and # has sufficient space -XX:HeapDumpPath=data # specify an alternative path for JVM fatal error logs -XX:ErrorFile=logs/hs_err_pid%p.log ## GC logging -Xlog:gc*,gc+age=trace,safepoint:file=logs/gc.log:utctime,pid,tags:filecount=32,filesize=64m elasticsearch-1.2....

heap dumps # generate a heap dump when an allocation from the Java heap fails # heap dumps are created in the working directory of the JVM -XX:+HeapDumpOnOutOfMemor # specify an alternative path for heap dumps; ensure the directory exists and # has sufficient space -XX:HeapDumpPath=data # specify an alternative path for JVM fatal error logs -XX:ErrorFile=logs/hs_err_pid%p.log ## GC logging -Xlog:gc*,gc+age=trace,safepoint:file=logs/gc.log:utctime,pid,tags:filecount=32,filesize=64m elasticsearch-1.2....

heap dumps # generate a heap dump when an allocation from the Java heap fails # heap dumps are created in the working directory of the JVM -XX:+HeapDumpOnOutOfMemor # specify an alternative path for heap dumps; ensure the directory exists and # has sufficient space -XX:HeapDumpPath=data # specify an alternative path for JVM fatal error logs -XX:ErrorFile=logs/hs_err_pid%p.log ## GC logging -Xlog:gc*,gc+age=trace,safepoint:file=logs/gc.log:utctime,pid,tags:filecount=32,filesize=64m elasticsearch-1.2....

@Documented
@GwtCompatible
public @interface GwtIncompatible {
  /**
   * Describes why the annotated element is incompatible with GWT. Since this is generally due to a
   * dependence on a type/method which GWT doesn't support, it is sufficient to simply reference the
   * unsupported type/method. E.g. "Class.isInstance".
   *
   * <p>As of Guava 20.0, this value is optional. We encourage authors who wish to describe why an

Base64 pode codificar dados binários em strings, mas, para isso, precisa usar mais caracteres do que os dados binários originais; assim, normalmente é menos eficiente do que arquivos comuns.

Use base64 apenas se realmente precisar incluir dados binários em JSON e não puder usar arquivos para isso.

## Pydantic `bytes` { #pydantic-bytes }

 * </ol>
 *
 * <p>This particular order of operations may be unrealistic, and testing all 3^5 of them may be
 * thought of as overkill; however, it's difficult to determine which proper subset of this massive
 * set would be sufficient to expose any possible bug. Brute force is simpler.
 *
 * <p>To use this class the concrete subclass must implement the {@link
 * IteratorTester#newTargetIterator()} method. This is because it's impossible to test an Iterator

            throw new SMBProtocolDecodingException("Invalid negotiate context count: " + negotiateContextCount + " (must be 0-100)");
        }

        bufferIndex += 4;

        // Validate sufficient buffer space for server GUID and capabilities
        if (buffer.length < bufferIndex + 16 + 4 + 4 + 4 + 4) {
            throw new SMBProtocolDecodingException("Buffer too small for server GUID and capabilities section");

     *
     * <p>Implementations should handle any task-specific logic and may communicate
     * errors by throwing an {@link Exception}. Error conditions should provide
     * sufficient detail to aid troubleshooting.</p>
     *
     * @throws Exception if any issue occurs that prevents the successful execution
     *                   of the Mojo
     */
    void execute() throws Exception;

        assertTrue(seq3 > seq2);
    }

    @Test
    void testHeartbeatUpdate() throws InterruptedException {
        long initialTime = registration.getLastHeartbeat();

        Thread.sleep(50); // Ensure sufficient time difference
        registration.updateHeartbeat();

        // After update, should not be expired with long timeout
        assertFalse(registration.isExpired(60000));

Base64 puede codificar datos binarios en strings, pero para hacerlo necesita usar más caracteres que los datos binarios originales, así que normalmente sería menos eficiente que los archivos normales.

Usa base64 solo si definitivamente necesitas incluir datos binarios en JSON y no puedes usar archivos para eso.

## Pydantic `bytes` { #pydantic-bytes }