assertSame(innerTree, inner, "Should return correct inner tree");
    }

    /**
     * Test for unwrap with incompatible type.
     * Verifies behavior when trying to unwrap to an incompatible type.
     */
    @Test
    void testUnwrap_incompatibleType() {
        when(smbTree.unwrap(IncompatibleTree.class)).thenReturn(null);

    }

    @Test
    @DisplayName("unwrap returns self for assignable type; throws for incompatible and null")
    void testUnwrap() {
        // Happy path: unwrap to concrete type
        SmbPipeHandleImpl unwrapped = target.unwrap(SmbPipeHandleImpl.class);
        assertSame(target, unwrapped);

        // Incompatible type: expect ClassCastException
        class OtherPipeHandle implements SmbPipeHandle {
            @Override

     * @param object the object to cast
     * @return object cast to type
     * @throws PACDecodingException if types are incompatible
     */
    public static <T> T as(final Class<T> type, final Object object) throws PACDecodingException {
        if (!type.isInstance(object)) {
            throw new PACDecodingException("Incompatible object types " + type + " " + object.getClass());
        }

        return type.cast(object);
    }

        // Test failed casting
        Object obj = 123; // Integer
        assertThrows(PACDecodingException.class, () -> {
            ASN1Util.as(String.class, obj);
        }, "Should throw PACDecodingException for incompatible types");
    }

    // --- as(Class, Enumeration) ---

    @Test
    void testAs_Enumeration_Success() throws PACDecodingException {
        // Test successful casting from enumeration

        // Test getInfo with incompatible class throws exception
        response = new Trans2QueryFSInformationResponse(config, FileSystemInformation.SMB_INFO_ALLOCATION);

        // Set info to SmbInfoAllocation
        SmbInfoAllocation allocation = new SmbInfoAllocation();
        setInfoField(response, allocation);

        // Try to get as FileFsSizeInformation (incompatible)

        // Close of try-with-resources should call close on the mock
        verify(tree, times(1)).close();
    }

    @Test
    @DisplayName("unwrap: returns self for compatible type and throws for incompatible")
    @SuppressWarnings({ "rawtypes", "unchecked" })
    void testUnwrap() {
        SmbSessionImpl session = newSession();

        // Happy path: ask for SmbSession and SmbSessionInternal

    @SuppressWarnings("unchecked")
    public <T extends Decodable> T getInfo(final Class<T> clazz) throws CIFSException {
        if (!clazz.isAssignableFrom(this.info.getClass())) {
            throw new CIFSException("Incompatible file information class");
        }
        return (T) getInfo();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb2.ServerMessageBlock2#writeBytesWireFormat(byte[], int)
     */

    @Override
    public final void setResponse(final CommonServerMessageBlockResponse msg) {
        if (msg != null && !(msg instanceof ServerMessageBlock2)) {
            throw new IllegalArgumentException("Incompatible response");
        }
        this.response = (T) msg;
    }

    public <T extends FileSystemInformation> T getInfo(final Class<T> clazz) throws CIFSException {
        if (!clazz.isAssignableFrom(this.info.getClass())) {
            throw new CIFSException("Incompatible file information class");
        }
        return (T) getInfo();
    }

    @Override
    protected int writeSetupWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

        FileBasicInfo info = response.getInfo(FileBasicInfo.class);
        assertNotNull(info);
        assertTrue(info instanceof FileBasicInfo);
    }

    @Test
    @DisplayName("Test getInfo with incompatible type throws CIFSException")
    void testGetInfoWithIncompatibleType() throws Exception {
        response = new Trans2QueryPathInformationResponse(mockConfig, FileInformation.FILE_BASIC_INFO);