import org.gradle.internal.resolve.result.BuildableArtifactFileResolveResult;
import org.gradle.internal.resolve.result.BuildableArtifactSetResolveResult;
import org.gradle.internal.resolve.result.BuildableModuleComponentMetaDataResolveResult;
import org.gradle.internal.resolve.result.BuildableModuleVersionListingResolveResult;
import org.gradle.internal.resolve.result.DefaultBuildableModuleComponentMetaDataResolveResult;

import org.gradle.internal.resolve.result.BuildableArtifactFileResolveResult;
import org.gradle.internal.resolve.result.BuildableArtifactSetResolveResult;
import org.gradle.internal.resolve.result.BuildableModuleComponentMetaDataResolveResult;
import org.gradle.internal.resolve.result.BuildableModuleVersionListingResolveResult;
import org.gradle.internal.resolve.result.ErroringResolveResult;

import java.util.Map;

        }
        result.nextControlFlow("else");
        result.addStatement("$L = false", varargMatched);
        result.addStatement("break");
        result.endControlFlow();

        result.endControlFlow();
        result.beginControlFlow("if ($L)", varargMatched);
        paramVariablesStack.push(varargVariable);

        val resolver = tracingCodeResolver()
        val result = schema.resolve(
            """
            f(0) // must be an unresolved property x
            """.trimIndent(),
            resolver
        )

        val call = result.additions.single().dataObject.originElement as FunctionCall
        assertIs<ObjectOrigin.FunctionOrigin>(resolver.trace.expressionResolution(call).result)

    assertThat(ComparisonChain.start().compareFalseFirst(true, true).result()).isEqualTo(0);
    assertThat(ComparisonChain.start().compareFalseFirst(true, false).result()).isGreaterThan(0);
    assertThat(ComparisonChain.start().compareFalseFirst(false, true).result()).isLessThan(0);
    assertThat(ComparisonChain.start().compareFalseFirst(false, false).result()).isEqualTo(0);
  }

  public void testCompareTrueFirst() {

    }

    @Override
    protected <RESULT extends DataConfig> RESULT createEntity(Map<String, Object> source, Class<? extends RESULT> entityType) {
        try {
            final RESULT result = entityType.newInstance();
            result.setAvailable(DfTypeUtil.toBoolean(source.get("available")));
            result.setBoost(DfTypeUtil.toFloat(source.get("boost")));
            result.setCreatedBy(DfTypeUtil.toString(source.get("createdBy")));

        given:
        runner.tasksToRun = ['visitZip']
        runner.addBuildMutator { createArchive(it, "archive.zip") { contents, output -> contents.zipTo(output) } }

        when:
        def result = runner.run()

        then:
        result.assertCurrentVersionHasNotRegressed()
    }

    @RunFor(
        @Scenario(type = PER_DAY, operatingSystems = [LINUX], testProjects = ["archivePerformanceProject"])
    )

  override fun hashCode(): Int {
    var result = 0
    result = 31 * result + name.hashCode()
    result = 31 * result + tagClass
    result = 31 * result + tag.toInt()
    result = 31 * result + codec.hashCode()
    result = 31 * result + (if (isOptional) 1 else 0)
    result = 31 * result + defaultValue.hashCode()
    result = 31 * result + (if (typeHint) 1 else 0)
    return result
  }

        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

        } else if (result instanceof InternalTaskSkippedResult) {
            return new DefaultTaskSkippedResult(result.getStartTime(), result.getEndTime(), ((InternalTaskSkippedResult) result).getSkipMessage());
        } else if (result instanceof InternalTaskFailureResult) {
            return new DefaultTaskFailureResult(result.getStartTime(), result.getEndTime(), toFailures(result.getFailures()), toTaskExecutionDetails(result));