assertNotNull(Curl.head("https://cdn.example.com/assets/file.js"));
        assertNotNull(Curl.options("http://cors.example.com/api"));
        assertNotNull(Curl.connect("http://proxy.example.com:3128"));
    }

    @Test
    public void test_HttpMethodEnumValues() {
        // ## Test that all expected HTTP methods are present in the enum ##

        // ## Act ##

        // + 1 byte 0x00
        // + context
        System.arraycopy(context, 0, suffix, label.length + 1, context.length);
        // + 4 byte (== r bits) big endian encoding of L
        suffix[suffix.length - 1] = (byte) 128;

        final DerivationParameters param = new KDFCounterParameters(sessionKey, null /* prefix */, suffix /* suffix */, r /* r */);
        gen.init(param);

        final byte[] derived = new byte[16];

            byte[] buffer = new byte[512];
            System.arraycopy(SMBUtil.SMB2_HEADER, 0, buffer, 0, 4);
            SMBUtil.writeInt4(128, buffer, 20); // nextCommand = 128 (not final)

            testMessage.setBytesRead(10);

            int len = testMessage.decode(buffer, 0, false);

            // Length should include padding for alignment

        case 23:
            ms_usage = 13;
        }
        return ms_usage;
    }

    /**
     * Calculates a MAC using HMAC-SHA1 with AES key derivation.
     * This method supports both AES-128 and AES-256 encryption types.
     *
     * @param usage the Kerberos key usage number for this operation
     * @param baseKey the base Kerberos key for key derivation
     * @param input the data to calculate the MAC for

    public String getId() {
        return getDependencyConflictId() + ":" + getBaseVersion();
    }

    @Override
    public String getDependencyConflictId() {
        StringBuilder sb = new StringBuilder(128);
        sb.append(getGroupId());
        sb.append(':');
        appendArtifactTypeClassifierString(sb);
        return sb.toString();
    }

      next = (next >>> 8) ^ Crc32cHashFunction.Crc32cHasher.byteTable[next & 0xFF];
    }
    int[][] expected = new int[4][256];
    for (int b = 0; b < 4; ++b) {
      for (int bit = 128; bit != 0; bit >>= 1) {
        expected[b][bit] = next;
        next = advanceOneBit(next);
      }
    }
    for (int b = 0; b < 4; ++b) {
      expected[b][0] = 0;

pkg syscall (netbsd-arm64-cgo), const SO_ERROR ideal-int
pkg syscall (netbsd-arm64-cgo), const SO_KEEPALIVE = 8
pkg syscall (netbsd-arm64-cgo), const SO_LINGER = 128
pkg syscall (netbsd-arm64-cgo), const SOL_SOCKET = 65535
pkg syscall (netbsd-arm64-cgo), const SOMAXCONN = 128
pkg syscall (netbsd-arm64-cgo), const SO_NOHEADER = 4106
pkg syscall (netbsd-arm64-cgo), const SO_NOHEADER ideal-int

    }

    @Test
    @DisplayName("Test log encryption")
    void testLogEncryption() {
        logger.logEncryption(true, "AES-128-GCM", "SMB3.1.1");

        Map<EventType, Long> stats = logger.getStatistics();
        assertEquals(Long.valueOf(1), stats.get(EventType.ENCRYPTION_ENABLED), "Should have 1 encryption event");
    }

    @Test

                    ciphers.add(EncryptionNegotiateContext.CIPHER_AES256_GCM);
                    ciphers.add(EncryptionNegotiateContext.CIPHER_AES256_CCM);
                }

                // Always include AES-128 for compatibility
                ciphers.add(EncryptionNegotiateContext.CIPHER_AES128_GCM);
                ciphers.add(EncryptionNegotiateContext.CIPHER_AES128_CCM);

    assertThat(formEncode(124)).isEqualTo("%7C")
    assertThat(formEncode(125)).isEqualTo("%7D")
    assertThat(formEncode(126)).isEqualTo("%7E")
    assertThat(formEncode(127)).isEqualTo("%7F")
    assertThat(formEncode(128)).isEqualTo("%C2%80")
    assertThat(formEncode(255)).isEqualTo("%C3%BF")
  }

  @Throws(IOException::class)
  private fun formEncode(codePoint: Int): String {