assertEquals(flags, parsed.getContextFlags(), "Context flags should parse from DER BIT STRING");
    }

    @Test
    @DisplayName("Sanity: toByteArray produces APPLICATION class wrapper and valid structure")
    void testToByteArrayStructureSanity() throws Exception {
        NegTokenInit init =

            assertTrue(metrics.totalSuccesses() > 0, "Should have some successes");
            assertTrue(metrics.successRate() >= 0 && metrics.successRate() <= 100, "Success rate should be valid percentage");

        } finally {
            cbWithWindow.close();
        }
    }

    @Test
    public void testCircuitBreakerClose() throws Exception {

pkg net, method (*UDPConn) WriteToUDPAddrPort([]uint8, netip.AddrPort) (int, error)
pkg net, type Error interface, Temporary //deprecated
pkg net/http, func MaxBytesHandler(Handler, int64) Handler
pkg net/http, method (*Cookie) Valid() error
pkg net/netip, func AddrFrom16([16]uint8) Addr
pkg net/netip, func AddrFrom4([4]uint8) Addr
pkg net/netip, func AddrFromSlice([]uint8) (Addr, bool)
pkg net/netip, func AddrPortFrom(Addr, uint16) AddrPort

            .post("Uncompressed".toRequestBody())
            .gzip()
            .build(),
        ).execute()
    val responseBody = response.body
    assertThat(responseBody.string(), "Expected response body to be valid")
      .isEqualTo("Uncompressed")
    responseBody.close()
    networkLogs
      .assertLogEqual("--> POST $url http/1.1")
      .assertLogEqual("Content-Encoding: gzip")

          shift += 24;
          len += 3;
        } else {
          int codePoint = Character.codePointAt(input, i);
          if (codePoint == c) {
            // not a valid code point; let the JDK handle invalid Unicode
            return hashBytes(input.toString().getBytes(charset));
          }
          i++;
          buffer |= codePointToFourUtf8Bytes(codePoint) << shift;

    /**
     * Validate host name
     */
    private boolean isValidHost(String host) {
        if (host == null || host.isEmpty()) {
            return false;
        }

        // Check for valid hostname or IP address
        // Simple validation - can be enhanced
        if (host.length() > 255) {
            return false;
        }

        // Check for invalid characters

        recordNameField.setAccessible(true);
        Name mockRecordName = new Name(mockConfig);
        recordNameField.set(nameQueryResponse, mockRecordName);

        // Prepare a byte array with valid NetBIOS name format
        byte[] src = new byte[100];
        int srcIndex = 0;

        // Start with compressed name pointer (0xC0) to use questionName
        src[srcIndex] = (byte) 0xC0;

```JSON
{
    "detail": [
        {
            "loc": [
                "path",
                "item_id"
            ],
            "msg": "value is not a valid integer",
            "type": "type_error.integer"
        }
    ]
}
```

devido ao parâmetro da rota `item_id` ter um valor `"foo"`, que não é um `int`.

        assertEquals(CrawlerStatus.INITIALIZING, values[0]);
        assertEquals(CrawlerStatus.RUNNING, values[1]);
        assertEquals(CrawlerStatus.DONE, values[2]);
    }

    /**
     * Test valueOf method with valid values
     */
    public void test_valueOf_valid() {
        assertEquals(CrawlerStatus.INITIALIZING, CrawlerStatus.valueOf("INITIALIZING"));
        assertEquals(CrawlerStatus.RUNNING, CrawlerStatus.valueOf("RUNNING"));

    public void setUp() throws Exception {
        super.setUp();
        // Create a test implementation of ScriptEngine
        scriptEngine = new TestScriptEngine();
    }

    // Test evaluate method with valid template and parameters
    public void test_evaluate_withValidTemplateAndParams() {
        String template = "Hello ${name}";
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("name", "World");