{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},
		{"todo.txt", "Get animal handling license."},
	}
	for _, file := range files {
		hdr := &tar.Header{
			Name: file.Name,
			Mode: 0600,
			Size: int64(len(file.Body)),
		}
		if err := tw.WriteHeader(hdr); err != nil {
			log.Fatal(err)
		}
		if _, err := tw.Write([]byte(file.Body)); err != nil {
			log.Fatal(err)
		}
	}

4 MOVQ 32(BX), AX MULQ SI ADDQ 32(CX), AX ADCQ $0x00, DX ADDQ DI, AX ADCQ $0x00, DX MOVQ DX, DI MOVQ AX, 32(CX) // Iteration 5 MOVQ 40(BX), AX MULQ SI ADDQ 40(CX), AX ADCQ $0x00, DX ADDQ DI, AX ADCQ $0x00, DX MOVQ DX, DI MOVQ AX, 40(CX) // Iteration 6 MOVQ 48(BX), AX MULQ SI ADDQ 48(CX), AX ADCQ $0x00, DX ADDQ DI, AX ADCQ $0x00, DX MOVQ DX, DI MOVQ AX, 48(CX) // Iteration 7 MOVQ 56(BX), AX MULQ SI ADDQ 56(CX), AX ADCQ $0x00, DX ADDQ DI, AX ADCQ $0x00, DX MOVQ DX, DI MOVQ AX, 56(CX) // Iteration 8...

```mermaid
graph LR

browser("Browser")
proxy["Proxy on http://0.0.0.0:9999/api/v1/app"]
server["Server on http://127.0.0.1:8000/app"]

browser --> proxy
proxy --> server
```

/// tip | Dica

O IP `0.0.0.0` é comumente usado para significar que o programa escuta em todos os IPs disponíveis naquela máquina/servidor.

///

        }
    }

    public void test_setMonitorInterval() {
        jobHelper.setMonitorInterval(3600);
        assertEquals(3600, jobHelper.monitorInterval);

        jobHelper.setMonitorInterval(1800);
        assertEquals(1800, jobHelper.monitorInterval);
    }

    public void test_getJobRuntime_null() {
        assertNull(jobHelper.getJobRuntime());
    }

    public void test_monitorTarget_expired_withoutEndTime() {

     * .
     */
    @Test
    public void testToBinary() {
        assertThat(BinaryConversionUtil.toBinary(null), nullValue());
        final byte[] b = { 0x00, 0x01 };
        assertThat(BinaryConversionUtil.toBinary(b), is(b));
        assertThat(BinaryConversionUtil.toBinary("hoge"), is("hoge".getBytes()));
    }

    /**
     * Test method for

    assertThat(Adapters.OBJECT_IDENTIFIER.toDer(SHA256_WITH_RSA_ENCRYPTION)).isEqualTo(bytes)
  }

  @Test fun `null value`() {
    val bytes = "0500".decodeHex()
    assertThat(Adapters.NULL.fromDer(bytes)).isNull()
    assertThat(Adapters.NULL.toDer(null)).isEqualTo(bytes)
  }

  @Test fun `sequence algorithm`() {

    class HexConversionTests {

        @Test
        @DisplayName("Various byte values are converted to uppercase hex")
        void testHexConversion() {
            byte[] challenge = new byte[] { (byte) 0x00, (byte) 0x0F, (byte) 0x10, (byte) 0x7F, (byte) 0x80, (byte) 0xFF };
            UniAddress dc = mock(UniAddress.class);
            when(dc.toString()).thenReturn("DC");

        int nameType = mockNetbiosName.getNameType();

        // Then
        assertEquals(testType, nameType);
        verify(mockNetbiosName).getNameType();
    }

    @ParameterizedTest
    @ValueSource(ints = { 0x00, 0x03, 0x06, 0x1B, 0x1C, 0x1D, 0x1E, 0x20 })
    @DisplayName("Should handle various NetBIOS name types")
    void testVariousNameTypes(int nameType) {
        // Given

        SMBUtil.writeInt2(0, buffer, 4);

        // Act & Assert
        assertEquals(0, response.readSetupWireFormat(buffer, 0, 100));
        assertEquals(6, response.readParametersWireFormat(buffer, 0, 100));
        assertEquals(0, response.readDataWireFormat(buffer, 0, 100));
    }

    @Test
    @DisplayName("Methods should handle empty buffer")
    void testMethodsWithEmptyBuffer() {
        // Arrange

    assertEscaping(e, "%7F", '\u007f'); // del
    assertEscaping(e, "%C2%80", '\u0080'); // xx-00010,x-000000
    assertEscaping(e, "%DF%BF", '\u07ff'); // xx-11111,x-111111
    assertEscaping(e, "%E0%A0%80", '\u0800'); // xxx-0000,x-100000,x-00,0000
    assertEscaping(e, "%EF%BF%BF", '\uffff'); // xxx-1111,x-111111,x-11,1111
    assertUnicodeEscaping(e, "%F0%90%80%80", '\uD800', '\uDC00');