}

internal class KaFirLocalVariableSymbol(firSymbol: FirPropertySymbol, analysisSession: KaFirSession) :
    KaFirLocalOrErrorVariableSymbol<FirProperty, FirPropertySymbol>(firSymbol, analysisSession) {
    init {
        assert(firSymbol.isLocal)
    }

    override val isVal: Boolean get() = withValidityAssertion { firSymbol.isVal }
}

internal class KaFirErrorVariableSymbol(
    firSymbol: FirErrorPropertySymbol,

     */
    ReceivedProblem receivedProblem(int index) {
        assert index >= 0: "Index must be non-negative"
        assert index < getReceivedProblems().size(): "Only ${getReceivedProblems().size()} problems received"
        def problems = getReceivedProblems()
        def result = problems[index]
        assert result != null: "Problem already validated"
        problems.set(index, null)
        return result

// than the type parameter list, and it may contain nil types. Matching type
// parameters and arguments must have the same index.
func newUnifier(tparams []*TypeParam, targs []Type, enableInterfaceInference bool) *unifier {
	assert(len(tparams) >= len(targs))
	handles := make(map[*TypeParam]*Type, len(tparams))
	// Allocate all handles up-front: in a correct program, all type parameters
	// must be resolved and thus eventually will get a handle.

                void transform(TransformOutputs outputs) {
                    def input = inputArtifact.get().asFile
                    println "processing [\${input.name}]"
                    assert input.file
                    for (def i : 1..parameters.multiplier.get()) {
                        def output = outputs.file(input.name + "." + parameters.targetColor.get() + "-" + i)

            List<File> copiedOriginalJars = copiedClassPath.getAsFiles();
            List<File> transformedJars = transformedClassPath.getAsFiles();
            int size = copiedOriginalJars.size();
            assert size == transformedJars.size();
            TransformedClassPath.Builder result = TransformedClassPath.builderWithExactSize(size);
            for (int i = 0; i < size; ++i) {

            def files = files('files/a', 'files/b').minus(files('files/b'))
            task copy(type: Copy) {
                from files
                into 'dest'
            }
        """

        when:
        run 'copy'

        then:
        file('dest').assertHasDescendants(
            'one.txt'
        )

        when:
        file('files/b/ignore.txt').createFile()
        run 'copy'

    }

    private void conversionFails(Object value) {
        try {
            JavaVersion.toVersion(value)
            org.junit.Assert.fail()
        } catch (IllegalArgumentException e) {
            assert e.getMessage() == "Could not determine Java version from '" + value + "'."
        }
    }

    def "uses system property to determine if compatible with Java #versionString"() {

                void setArchiveName(String value) { archiveFileName.set(value) }

                @TaskAction
                void doIt() {
                    assert archiveFileName.get() == "something"
                }
            }

            task myTask(type: MyTask) {
                conventionMapping('archiveName') { 'not something' }

        parameter.taskNames = null

        then:
        assertRunsDefaultTasks(parameter)
    }

    private void assertRunsDefaultTasks(StartParameter parameter) {
        assert parameter.taskNames.empty
        assert parameter.taskRequests.size() == 1 && parameter.taskRequests[0] instanceof RunDefaultTasksExecutionRequest
    }

	ExecObjectLayerAPINilTest(t, nilBucket, nilObject, instanceType, apiRouter, nilReq)
}

func TestAPIHeadObjectHandlerWithEncryption(t *testing.T) {
	globalPolicySys = NewPolicySys()
	defer func() { globalPolicySys = nil }()

	defer DetectTestLeak(t)()