val symbol: Int

    /** Number of bits represented in the terminal node. */
    val terminalBitCount: Int

    /** Construct an internal node. */
    constructor() {
      this.children = arrayOfNulls(256)
      this.symbol = 0 // Not read.
      this.terminalBitCount = 0 // Not read.
    }

    /** Construct a terminal node. */
    constructor(symbol: Int, bits: Int) {
      this.children = null

            return; // Skip sizes larger than buffer
        }

        byte[] sourceData = new byte[dataSize];
        for (int i = 0; i < dataSize; i++) {
            sourceData[i] = (byte) (i % 256);
        }

        byte[] buffer = new byte[dataSize + 50];
        System.arraycopy(sourceData, 0, buffer, 10, dataSize);

        int result = response.readDataWireFormat(buffer, 10, dataSize);

        @BeforeEach
        void setUp() {
            testName = "CREATE_CONTEXT_TEST".getBytes(StandardCharsets.UTF_8);
            testResponse = new TestCreateContextResponse(testName);
            testBuffer = new byte[256];
            Arrays.fill(testBuffer, (byte) 0x42);
        }

        @Test
        @DisplayName("Should correctly store and return name")
        void testNameStorage() {

    private byte[] calculateBindingHash(byte[] bindingInfo) throws IOException {
        try {
            MessageDigest digest = MessageDigest.getInstance("SHA-256");
            return digest.digest(bindingInfo);
        } catch (NoSuchAlgorithmException e) {
            throw new IOException("SHA-256 not available", e);
        }
    }
    
    public ChannelInfo selectChannel(SMBMessage message) {

        if (log.isTraceEnabled()) {
            log.trace("update: " + this.updates + " " + offset + ":" + len);
            log.trace(Hexdump.toHexString(input, offset, Math.min(len, 256)));
        }
        if (len == 0) {
            return; /* CRITICAL */
        }
        this.digest.update(input, offset, len);
        this.updates++;
    }

    /**

        byte[] fileId = new byte[16];
        Arrays.fill(fileId, (byte) 0xCC);

        byte[] header = buildSmb2Header();
        int ctxOffsetFromHeader = 256; // arbitrary aligned location beyond header
        byte[] baseBody = buildCreateBodyWithContext(fileId, ctxOffsetFromHeader);

        // Build actual context bytes matching the pointers inside baseBody

	MOVD -391(R17), R3                         // 3b1e06d1630340f9
	MOVD -257(R17), R3                         // 3b0604d1630340f9
	MOVD -256(R17), R3                         // 230250f8
	MOVD 255(R17), R3                          // 23f24ff8
	MOVD 256(R17), R3                          // 238240f9
	MOVD 257(R17), R3                          // 3b060491630340f9
	MOVD 391(R17), R3                          // 3b1e0691630340f9

    }

    @Test
    @DisplayName("Test decode method")
    void testDecode() throws Exception {
        // Test the decode method which is inherited from ServerMessageBlock
        byte[] buffer = new byte[256];

        // Set up a minimal SMB header (size 32 bytes)
        // SMB signature
        buffer[0] = (byte) 0xFF;
        buffer[1] = 'S';
        buffer[2] = 'M';
        buffer[3] = 'B';

            this.preauthSalt = salt;

            if (config.isEncryptionEnabled()) {
                // Build cipher list based on AES-256 support
                List<Integer> ciphers = new ArrayList<>();

                // Prefer GCM over CCM for better performance
                if (config.isAES256Enabled()) {

    void testMaxOffsetBoundary() {
        // Arrange
        byte[] largeData = new byte[1000];
        for (int i = 0; i < largeData.length; i++) {
            largeData[i] = (byte) (i % 256);
        }
        int offset = 990;
        int length = 10;

        TransTransactNamedPipe trans = new TransTransactNamedPipe(mockConfig, TEST_FID, largeData, offset, length);
        byte[] dst = new byte[100];