}
        if (clazz.isAssignableFrom(Date.class)) {
            if (value instanceof Date) {
                return (T) value;
            }
            return (T) FessFunctions.parseDate(value.toString());
        }
        if (clazz.isAssignableFrom(Long.class)) {
            if (value instanceof Long) {
                return (T) value;
            }

    def "assembles schema for @Managed type"() {
        expect:
        def schema = store.getSchema(ModelType.of(SomeType))
        schema instanceof ManagedImplStructSchema
        schema instanceof ManagedImplSchema
        schema instanceof CompositeSchema
        schema instanceof StructSchema
        schema.propertyNames == ['readOnlyString', 'strings'] as SortedSet
        schema.properties*.name == ['readOnlyString', 'strings']

    public boolean canTransform(Object[] args) {
        for (Object arg : args) {
            if (arg instanceof CharSequence) {
                return true;
            }
        }
        return false;
    }

    @Override
    public Object transformValue(Class<?> type, Object value) {
        if (value instanceof CharSequence && type.isEnum()) {

        return (type instanceof Class && clazz.isAssignableFrom((Class<?>) type))
            || (type instanceof ParameterizedType && clazz.isAssignableFrom((Class<?>) ((ParameterizedType) type).getRawType()));
    }

    /**
     * Returns the services available for injection into the implementation instance.
     */

      @Override
      public boolean equals(@CheckForNull Object that) {
        if (that instanceof Pred) {
          return this.node.equals(((Pred<?>) that).node);
        } else {
          return false;
        }
      }

      @Override
      public int hashCode() {
        // Adding the class hashCode to avoid a clash with Succ instances.
        return Pred.class.hashCode() + node.hashCode();
      }
    }

        super(params);
    }

    @Override
    public Violation maybeViolation(final JApiCompatibility member) {
        if (member instanceof JApiMethod || member instanceof JApiField || member instanceof JApiClass || member instanceof JApiConstructor) {
            if (!isIncubating((JApiHasAnnotations) member) && !isInject((JApiHasAnnotations) member)) {
                return violationError(member);
            }

                }
            }
            return true;
        }
        if (wrapper instanceof ClassTypeWrapper) {
            if (!rawType.equals(wrapper)) {
                return false;
            }
            for (TypeWrapper typeArgument : actualTypeArguments) {
                if (!(typeArgument instanceof WildcardWrapper)) {
                    return false;
                }

        if (params.length == 1 && params[0] instanceof Closure) {
            return DynamicInvokeResult.found(_container.create(name, (Closure<?>) params[0]));
        } else if (params.length == 1 && params[0] instanceof Class) {
            return DynamicInvokeResult.found(_container.create(name, Cast.<Class<T>>uncheckedCast(params[0])));
        } else if (params.length == 2 && params[0] instanceof Class && params[1] instanceof Closure){

        if (tree instanceof Buildable) {
            context.add(tree);
        } else if (tree instanceof TaskDependencyContainer) {
            ((TaskDependencyContainer) tree).visitDependencies(context);
        }
    }

    @Override
    public boolean contains(File file) {
        if (tree instanceof RandomAccessFileCollection) {

        collector.failures.size() == 1
        collector.failures[0] instanceof TestAssertionFailure
        def failure = collector.failures[0] as TestAssertionFailure
        failure.message == "This exception wraps an assertion error"

        // Extract and assert the wrapped failure
        failure.causes.size() == 1
        failure.causes[0] instanceof TestAssertionFailure
        def cause = failure.causes[0] as TestAssertionFailure