*             if the information cannot be cast to the specified type
     */
    @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}
     *

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

    @Override

        assertNotNull(impl, "Implementation instance should not be null");
        assertTrue(SessionSetupHandler.class.isInstance(impl), "Instance should be assignable to interface");
        assertTrue(SessionSetupHandler.class.isAssignableFrom(impl.getClass()), "Type should be assignable");
    }

    @Test
    @DisplayName("Edge: null is not an instance of the interface")
    void testNullIsNotInstance() {
        // Assert

            assertTrue(FileSystemInformation.class.isAssignableFrom(AllocInfo.class));
        }

        @Test
        @DisplayName("Should implement Decodable interface through FileSystemInformation")
        void shouldImplementDecodableInterface() {
            // Verify that AllocInfo indirectly implements Decodable
            assertTrue(jcifs.Decodable.class.isAssignableFrom(AllocInfo.class));
        }

        @Test

        }
        assertThrows(ClassCastException.class, () -> {
            OtherPipeHandle result = target.unwrap(OtherPipeHandle.class);
        });

        // Null input: document current behavior (NPE from isAssignableFrom)
        assertThrows(NullPointerException.class, () -> target.unwrap(null));
    }

    @Test
    @DisplayName("getPipe, getPipeType, getUncPath delegate to underlying pipe")
    void testBasicAccessors() {

      Iterator<Class<?>> iterator = interfaceClasses.iterator();
      boolean addToSet = true;
      while (iterator.hasNext()) {
        Class<?> current = iterator.next();
        if (current == itf || itf.isAssignableFrom(current)) {
          // Skip any super interface of the ones that are already included.
          addToSet = false;
          break;
        }
      }
      if (addToSet) {
        interfaceClasses.add(itf);

     * @param fromClass
     *            The source class. Must not be {@literal null}.
     * @return Whether assignment is possible.
     * @see Class#isAssignableFrom(Class)
     */
    public static boolean isAssignableFrom(final Class<?> toClass, Class<?> fromClass) {
        assertArgumentNotNull("toClass", toClass);
        assertArgumentNotNull("fromClass", fromClass);

    @Override
    public <T extends Address> T unwrap(final Class<T> type) {
        if (this.addr instanceof Address) {
            return ((Address) this.addr).unwrap(type);
        }
        if (this.getClass().isAssignableFrom(type)) {
            return (T) this;
        }
        return null;
    }

    /**
     * Return the a text representation of this address such as
     * <code>MYCOMPUTER/192.168.1.15</code>.

     */
    @SuppressWarnings("unchecked")
    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

        direction.directHtmlRendering(new JspHtmlRenderingProvider() {
            @Override
            protected String getShowErrorsForwardPath(final ActionRuntime runtime) {
                if (FessAdminAction.class.isAssignableFrom(runtime.getActionType())) {
                    return "/admin/error/error.jsp";
                }
                return "/error/system.jsp";
            }
        });
    }