*/

package org.gradle.internal.rules;

import org.gradle.api.GradleException;

public class RuleActionValidationException extends GradleException {
    public RuleActionValidationException(String message) {
        super(message);
    }

    public RuleActionValidationException(String message, Throwable cause) {
        super(message, cause);
    }

        failure.cause instanceof RuleActionValidationException
        failure.cause.message == "FAILED"
    }

    def "fails to adapt action when validation fails" () {
        def RuleActionValidator ruleActionValidator = Stub(RuleActionValidator) {
            validate(_) >> { RuleAction ruleAction -> throw new RuleActionValidationException("FAILED") }
        }

        ruleValidator.validate(Stub(RuleAction) {
            getInputTypes() >> { [ Long ] }
        })

        then:
        def failure = thrown(RuleActionValidationException)
        failure.message == "Rule may not have an input parameter of type: java.lang.Long. Second parameter must be of type: java.lang.Integer."
    }

    def "rejects invalid type when no type configured" () {

        try {
            return ruleActionValidator.validate(new ClosureBackedRuleAction<>(subjectType, closure));
        } catch (RuleActionValidationException e) {
            throw new InvalidUserCodeException(String.format(INVALID_CLOSURE_ERROR, context), e);
        }
    }

    @Override

        given:
        def closure = { Integer val ->
        }

        when:
        action(closure)

        then:
        def e = thrown RuleActionValidationException
        e.message == "First parameter of rule action closure must be of type 'String'."
    }

    def "fails to construct with multiple arg closure with incorrect subject"() {
        given:

import org.gradle.internal.resolve.caching.ComponentMetadataRuleExecutor
import org.gradle.internal.rules.RuleAction
import org.gradle.internal.rules.RuleActionAdapter
import org.gradle.internal.rules.RuleActionValidationException
import org.gradle.internal.serialize.Serializer
import org.gradle.internal.snapshot.ValueSnapshotter
import org.gradle.util.AttributeTestUtil
import org.gradle.util.SnapshotTestUtil
import org.gradle.util.TestUtil

    private void validateInputTypes(RuleAction<?> ruleAction) {
        for (Class<?> inputType : ruleAction.getInputTypes()) {
            if (!validInputType.contains(inputType)) {
                throw new RuleActionValidationException(invalidParameterMessage(inputType));
            }
        }
    }

    private String invalidParameterMessage(Class<?> inputType) {
        if (validInputType.isEmpty()) {

            if (parameterTypes[0].isAssignableFrom(subjectType)) {
                inputTypes.addAll(Arrays.asList(parameterTypes).subList(1, parameterTypes.length));
            } else {
                throw new RuleActionValidationException(String.format("First parameter of rule action closure must be of type '%s'.", subjectType.getSimpleName()));
            }
        }

        return inputTypes;
    }

    @Override

                }
            }
        }

        if (problemsFormatter.hasProblems()) {
            throw new RuleActionValidationException(problemsFormatter.format());
        }

        return new RuleSourceBackedRuleAction<>(ruleSourceInstance, new JavaMethod<>(subjectType.getConcreteClass(), mutateMethods.get(0)));
    }

    }

    def "fails to create rule action for invalid rule source"() {
        when:
        action = RuleSourceBackedRuleAction.create(listType, ruleSource)

        then:
        def e = thrown RuleActionValidationException
        e.message.startsWith("Type ${fullyQualifiedNameOf(ruleSource.class)} is not a valid rule source:")
        def messageReasons = getReasons(e.message)
        messageReasons.size() == reasons.size()