pkg syscall (freebsd-arm64), const IP_MAX_MEMBERSHIPS ideal-int
pkg syscall (freebsd-arm64), const IP_MAX_SOCK_MUTE_FILTER = 128
pkg syscall (freebsd-arm64), const IP_MAX_SOCK_MUTE_FILTER ideal-int
pkg syscall (freebsd-arm64), const IP_MAX_SOCK_SRC_FILTER = 128
pkg syscall (freebsd-arm64), const IP_MAX_SOCK_SRC_FILTER ideal-int
pkg syscall (freebsd-arm64), const IP_MAX_SOURCE_FILTER = 1024

        // + 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;

// is based on the un-escaped keys. It never returns an error.
func (c Context) MarshalText() ([]byte, error) {
	if len(c) == 0 {
		return []byte{'{', '}'}, nil
	}

	// Pre-allocate a buffer - 128 bytes is an arbitrary
	// heuristic value that seems like a good starting size.
	b := bytes.NewBuffer(make([]byte, 0, 128))
	if len(c) == 1 {
		for k, v := range c {
			b.WriteString(`{"`)
			escapeStringJSON(b, k)

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

    }

    @Test
    @DisplayName("Test readString with ASCII encoding")
    void testReadStringAscii() throws Exception {
        String testString = "TestString";
        byte[] buffer = new byte[128];
        byte[] stringBytes = testString.getBytes(StandardCharsets.US_ASCII);
        System.arraycopy(stringBytes, 0, buffer, 10, stringBytes.length);
        buffer[10 + stringBytes.length] = 0; // null terminator