for (long testValue : testValues) {
            // Create and encode
            FileEndOfFileInformation original = new FileEndOfFileInformation(testValue);
            byte[] buffer = new byte[8];
            int encoded = original.encode(buffer, 0);

            assertEquals(8, encoded);

            // Decode into new instance

            String originalMessage = "Original error";
            TransportException original = new TransportException(originalMessage);

            // Wrap in another exception
            TransportException wrapper = new TransportException("Wrapper", original);

            assertEquals("Wrapper", wrapper.getMessage());
            assertEquals(original, wrapper.getRootCause());

     */
    @Test
    void testConstructorWithMessageAndCause() {
        String message = "Test message with cause.";
        Throwable cause = new RuntimeException("Original cause.");
        DcerpcException exception = new DcerpcException(message, cause);

        assertEquals(0, exception.getErrorCode(), "Error code should be 0 for message and cause constructor.");

  }

  private static final class ReverseConverter<A, B> extends Converter<B, A>
      implements Serializable {
    final Converter<A, B> original;

    ReverseConverter(Converter<A, B> original) {
      this.original = original;
    }

    /*
     * These gymnastics are a little confusing. Basically this class has neither legacy nor

```

O **proxy** intercepta a requisição original do cliente e adiciona os headers especiais de encaminhamento (`X-Forwarded-*`) antes de repassar a requisição para o **servidor da aplicação**.

Esses headers preservam informações sobre a requisição original que, de outra forma, seriam perdidas:

* **X-Forwarded-For**: o endereço IP original do cliente
* **X-Forwarded-Proto**: o protocolo original (`https`)

    assert "Error processing docs/lang/docs/doc.md" in result.output
    assert (
        "Number of HTML links does not match the number "
        "in the original document (7 vs 6)"
    ) in result.output


@pytest.mark.parametrize(
    "copy_test_files",
    [(f"{data_path}/en_doc.md", f"{data_path}/translated_doc_number_lt.md")],
    indirect=True,
)

    assert "Error processing docs/lang/docs/doc.md" in result.output
    assert (
        "Number of markdown links does not match the number "
        "in the original document (7 vs 6)"
    ) in result.output


@pytest.mark.parametrize(
    "copy_test_files",
    [(f"{data_path}/en_doc.md", f"{data_path}/translated_doc_number_lt.md")],
    indirect=True,
)

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package jwt

// This file is a re-implementation of the original code here with some
// additional allocation tweaks reproduced using GODEBUG=allocfreetrace=1
// original file https://github.com/golang-jwt/jwt/blob/main/parser.go
// borrowed under MIT License https://github.com/golang-jwt/jwt/blob/main/LICENSE

import (
	"fmt"

JSON solo puede contener strings codificados en UTF-8, así que no puede contener bytes crudos.

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 }

   */
  E[] createArray(int length);

  /**
   * Returns the iteration ordering of elements, given the order in which they were added to the
   * container. This method may return the original list unchanged, the original list modified in
   * place, or a different list.
   *
   * <p>If the order is non-deterministic, as with {@link java.util.HashSet}, this method can return