DcerpcPipeHandle handle = createMockedDcerpcPipeHandle();
            byte[] expectedKey = "sessionKey".getBytes();
            when(mockSmbPipeHandleInternal.getSessionKey()).thenReturn(expectedKey);
            assertArrayEquals(expectedKey, handle.getSessionKey());
        }

        @Test
        @DisplayName("Should propagate CIFSException when getting session key")

    /**
     * Returns the current session key used for signing and encryption.
     *
     * @return the current session key
     * @throws CIFSException if the session key cannot be retrieved
     */
    byte[] getSessionKey() throws CIFSException;

    /**
     * Returns the SMB transport associated with this session.
     *
     * @return the transport for this session
     */
    SmbTransport getTransport();

    /**

    /**
     *
     * {@inheritDoc}
     *
     * @see jcifs.smb.SmbPipeHandleInternal#getSessionKey()
     */
    @Override
    public byte[] getSessionKey() throws CIFSException {
        try (SmbTreeHandleImpl th = ensureTreeConnected(); SmbSessionImpl sess = th.getSession()) {
            return sess.getSessionKey();
        }
    }

    /**
     * {@inheritDoc}
     *

    }

    @Override
    public String getServerWithDfs() {
        return this.pipe.getLocator().getServerWithDfs();
    }

    @Override
    public byte[] getSessionKey() throws CIFSException {
        return this.handle.getSessionKey();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.dcerpc.DcerpcHandle#doSendReceiveFragment(byte[], int, int, byte[])
     */
    @Override

    /**
     * Gets the session key after successful authentication
     *
     * @return the session key or null if not available
     */
    byte[] getSessionKey();

    /**
     * Gets the signing key for SMB2/3
     *
     * @return the signing key or null if not available
     */
    byte[] getSigningKey();

    /**
     * Validates authentication credentials

            return serverWithDfs;
        }

        @Override
        public CIFSContext getTransportContext() {
            return localTransportContext;
        }

        @Override
        public byte[] getSessionKey() throws CIFSException {
            return sessionKey;
        }

        @Override
        protected void doSendFragment(byte[] buf, int off, int length) throws IOException {

     * Gets the session key from the underlying SMB session.
     *
     * @return session key of the underlying smb session
     * @throws CIFSException if an error occurs retrieving the session key
     */
    byte[] getSessionKey() throws CIFSException;

    /**
     * Gets the input stream for reading from this pipe.
     *
     * @return this pipe's input stream
     * @throws CIFSException if an error occurs getting the input stream

        return masterKey;
    }

    /**
     * Returns the session key.
     *
     * @return A <code>byte[]</code> containing the session key.
     */
    public byte[] getSessionKey() {
        return sessionKey;
    }

    /**
     * Sets the session key.
     *
     * @param sessionKey The session key.
     */
    public void setSessionKey(final byte[] sessionKey) {

        multiConfig = new PropertyConfiguration(props);

        // Mock context and session for ChannelManager
        when(mockContext.getConfig()).thenReturn(multiConfig);
        when(mockSession.getSessionKey()).thenReturn(new byte[16]);

        channelManager = new ChannelManager(mockContext, mockSession);
    }

    @Test
    void testMultiChannelInitialization() throws Exception {

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        try {
            // Combine session key with channel-specific data
            byte[] sessionKey = getSessionKey();
            if (sessionKey != null) {
                baos.write(sessionKey);
            }
            baos.write(channel.getLocalInterface().getAddress().getAddress());