ExpectingFailureRuleStatement(Statement next, String feature) {
        this.next = next
        this.feature = feature
    }

    @Override
    void evaluate() throws Throwable {
        try {
            next.evaluate()
            throw new ToBeFixedSpecInterceptor.UnexpectedSuccessException(feature)
        } catch (ToBeFixedSpecInterceptor.UnexpectedSuccessException ex) {
            throw ex

        Statement base = Mock(Statement)
        Description description = Mock(Description)
        def statement = portAllocator.apply(base, description)

        when:
        statement.evaluate()

        then:
        1 * base.evaluate() >> {
            portAllocator.assignPort()
            portAllocator.assignPort()
        }
        2 * delegate.assignPort()

        and:
        2 * delegate.releasePort(_)
    }

    final def evaluator = new ConfigureActionsProjectEvaluator(action1, action2)

    def "executes all configuration actions"() {
        def project = Mock(ProjectInternal)

        when:
        evaluator.evaluate(project, state)

        then:
        1 * action1.execute(project)
        1 * action2.execute(project)
        0 * _._
    }

    def "does not continue executing actions when action fails"() {

    }

    @Override
    Statement apply(Statement base, Description description) {
        return new Statement() {
            @Override
            void evaluate() throws Throwable {
                base.evaluate()
                for (int port : portsAllocated) {
                    delegate.releasePort(port)
                }
                portsAllocated.clear()
            }
        }
    }

     *
     * @param project The which is to be evaluated. Never null.
     */
    void beforeEvaluate(Project project);

    /**
     * <p>This method is called when a project has been evaluated, and before the evaluated project is made available to
     * other projects.</p>
     *
     * @param project The project which was evaluated. Never null.

    public ArchRule as(String newDescription) {
        return new FreezeInstructionsPrintingArchRule(delegate.as(newDescription));
    }

    @Override
    public EvaluationResult evaluate(JavaClasses classes) {
        try {
            return delegate.evaluate(classes);
        } catch (RuntimeException e) {
            if (e.getMessage().contains("freeze.store")) {

                            << e5 << ") evaluates to false, where"
                            << "\n" << e1 << " evaluates to " << v1
                            << "\n" << e2 << " evaluates to " << v2
                            << "\n" << e3 << " evaluates to " << v3
                            << "\n" << e4 << " evaluates to " << v4
                            << "\n" << e5 << " evaluates to " << v5;
}

            @Override
            public void evaluate() throws Throwable {
                ExpectedFailure expectedFailureAnnotation = method.getAnnotation(ExpectedFailure.class);
                boolean expectedToFail = expectedFailureAnnotation != null;
                Throwable failed = null;
                try {
                    base.evaluate();
                } catch (Throwable t) {
                    failed = t;

                }
            }
            return expression;
        }

        public Object evaluate(String expression) throws ExpressionEvaluationException {
            return evaluate(expression, null);
        }

        public File alignToBaseDirectory(File file) {
            if (translator != null) {

        return new Statement() {
            @Override
            public void evaluate() throws Throwable {
                validateCustomProperties();
                System.getProperties().putAll(customProperties);
                try {
                    base.evaluate();
                } finally {
                    System.setProperties(properties);
                }
            }