* @param clazz
     *            the class type to cast the information to
     * @return the information
     * @throws CIFSException
     *             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())) {

    /**
     * Checks if the specified class is abstract.
     *
     * @param clazz
     *            the class to check. Must not be null.
     * @return true if abstract, false otherwise
     */
    public static boolean isAbstract(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        return isAbstract(clazz.getModifiers());
    }

    /**

       * trivially, but it's enough to skip these ones.
       */
      ) {
        continue;
      }
      Class<?> clazz = info.load();
      try {
        Method unused = clazz.getDeclaredMethod("writeReplace");
        continue; // It overrides writeReplace, so it's safe.
      } catch (NoSuchMethodException e) {

   */
  private Multimap<Class<?>, Subscriber> findAllSubscribers(Object listener) {
    Multimap<Class<?>, Subscriber> methodsInListener = HashMultimap.create();
    Class<?> clazz = listener.getClass();
    for (Method method : getAnnotatedMethods(clazz)) {
      Class<?>[] parameterTypes = method.getParameterTypes();
      Class<?> eventType = parameterTypes[0];

     */
    static <T> Key<T> key(Class<T> clazz) {
        return new Key<>(clazz, clazz);
    }

    /**
     * Create a key using the given class and id.
     */
    static <T> Key<T> key(Class<T> clazz, Object id) {
        return new Key<>(clazz, id);
    }

    /**
     * Key used to query the session data

    /**
     * Creates a new instance of JclLoggerAdapter.
     *
     * @param name the logger name
     */
    public JclLoggerAdapter(final Class<?> clazz) {
        sourceClass = clazz.getName();
        logger = LogFactory.getLog(clazz);
    }

    @Override
    public boolean isFatalEnabled() {
        return logger.isFatalEnabled();
    }

    @Override

  }

  static void assertSeedlessHashFunctionEquals(Class<?> clazz) throws Exception {
    for (Method method : clazz.getDeclaredMethods()) {
      if (shouldHaveKnownHashes(method)) {
        HashFunction hashFunction1a = (HashFunction) method.invoke(clazz);
        HashFunction hashFunction1b = (HashFunction) method.invoke(clazz);

        new EqualsTester().addEqualityGroup(hashFunction1a, hashFunction1b).testEquals();

    protected final String sourceClass;

    protected final java.util.logging.Logger logger;

    public JulLoggerAdapter(final Class<?> clazz) {
        sourceClass = clazz.getName();
        logger = java.util.logging.Logger.getLogger(clazz.getName());
    }

    @Override
    public boolean isFatalEnabled() {
        return logger.isLoggable(Level.SEVERE);
    }

    @Override

            } catch (ClassNotFoundException e) {
                return null;
            }
        }

        @Override
        public Class<?> toCompleteClass(Class<?> clazz) {
            return clazz;
        }

        @Override
        public String fromSuffixToPackageName(String suffix) {
            return "org.codelibs.fess";
        }

        @Override

        // Given
        Class<?> clazz = SmbComTreeDisconnect.class;

        // When & Then - verify methods are declared in this class (overridden)
        Method writeParameterWords = clazz.getDeclaredMethod("writeParameterWordsWireFormat", byte[].class, int.class);
        assertNotNull(writeParameterWords);

        Method writeBytes = clazz.getDeclaredMethod("writeBytesWireFormat", byte[].class, int.class);