expectReadBuildOperation(0)
        expectResourceRead(new ByteArrayInputStream())

        when:
        def result = accessor.withContent(location, false, action)

        then:
        result == "result"

        and:
        1 * action.execute(_, _) >> "result"
    }

    def "fires progress events as content is read"() {
        setup:
        metaData.getContentLength() >> 4096

	for _, ac := range e.Condition {
		result.combine(ac.analyze(s))
	}
	return
}

func (e *Condition) analyze(s *Select) (result qProp) {
	if e.Operand != nil {
		result = e.Operand.analyze(s)
	} else {
		result = e.Not.analyze(s)
	}
	return
}

func (e *ListExpr) analyze(s *Select) (result qProp) {
	for _, ac := range e.Elements {
		result.combine(ac.analyze(s))

        def graphState = Stub(ComponentGraphSpecificResolveState)

        when:
        result.resolved(state, graphState)

        then:
        result.moduleVersionId == id
        result.state == state
        result.graphState == graphState
    }

    def "cannot get id when no result has been specified"() {
        when:
        result.moduleVersionId

        then:
        IllegalStateException e = thrown()

        ITestResult result = Mock()

        when:
        adapter.onConfigurationSuccess(result)
        adapter.onConfigurationFailure(result)
        adapter.onConfigurationSkip(result)

        then:
        1 * listener.onConfigurationSuccess(result)
        1 * listener.onConfigurationFailure(result)
        1 * listener.onConfigurationSkip(result)
    }

    public void testIsToOs() throws Exception {
        final int result = copy(is, os);
        assertThat(result, is(srcBytes.length));
        assertThat(os.toByteArray(), is(srcBytes));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testReaderToWriter() throws Exception {
        final int result = copy(reader, writer);
        assertThat(result, is(srcString.length()));

			Constraint: "name <> 'jinzhu'",
		},
	}

	checks := user.ParseCheckConstraints()

	for k, result := range results {
		v, ok := checks[k]
		if !ok {
			t.Errorf("Failed to found check %v from parsed checks %+v", k, checks)
		}

		for _, name := range []string{"Name", "Constraint"} {
			if reflect.ValueOf(result).FieldByName(name).Interface() != reflect.ValueOf(v).FieldByName(name).Interface() {
				t.Errorf(

  }

  override fun hashCode(): Int {
    var result = 17
    result = 31 * result + url.hashCode()
    result = 31 * result + dns.hashCode()
    result = 31 * result + proxyAuthenticator.hashCode()
    result = 31 * result + protocols.hashCode()
    result = 31 * result + connectionSpecs.hashCode()
    result = 31 * result + proxySelector.hashCode()
    result = 31 * result + Objects.hashCode(proxy)

                    BuildActionRunner.Result result = delegate.execute(action, context);
                    buildOperationContext.setResult(RESULT);
                    if (result.getBuildFailure() != null) {
                        buildOperationContext.failed(result.getBuildFailure());
                    }
                    return result;
                }

                @Override

        then:
        def result = new DefaultTestExecutionResult(testDirectory)

        result.assertTestClassesExecuted('FooTest', 'BarTest')
        result.testClass('FooTest').assertTestCount(1, 0, 0)
        result.testClass('FooTest').assertTestOutcomes(passedTestOutcome, 'pass')
        result.testClass('BarTest').assertTestCount(1, 0, 0)
        result.testClass('BarTest').assertTestOutcomes(passedTestOutcome, 'pass')

        eventLogger.afterSuite(innerSuiteDescriptor, result)
        eventLogger.afterSuite(classDescriptor, result)

        then:
        textOutputFactory.toString().count("PASSED") == 3

        when:
        textOutputFactory.clear()
        eventLogger.afterSuite(rootDescriptor, result)
        eventLogger.afterSuite(workerDescriptor, result)
        eventLogger.afterTest(methodDescriptor, result)

        then: