// license that can be found in the LICENSE file.

// This is the input program for an end-to-end test of the DWARF produced
// by the compiler. It is compiled with various flags, then the resulting
// binary is "debugged" under the control of a harness.  Because the compile+debug
// step is time-consuming, the tests for different bugs are all accumulated here
// so that their cost is only the time to "n" through the additional code.

 */
package org.gradle.api.internal.tasks.compile.daemon;

import com.google.common.collect.Lists;
import org.gradle.api.tasks.WorkResult;
import org.gradle.api.tasks.compile.BaseForkOptions;
import org.gradle.internal.UncheckedException;
import org.gradle.language.base.internal.compile.CompileSpec;
import org.gradle.language.base.internal.compile.Compiler;
import org.gradle.workers.internal.DaemonForkOptions;

        spec()
        builder.build()
    }

    Object compiles() {
        def sources = generatedCode.values().collect {
            new TestClassSource(it.className, it.generatedCode)
        }
        def srcDir = tmpDir.createDir("src")
        def dstDir = tmpDir.createDir("dst")
        SimpleGeneratedJavaClassCompiler.compile(srcDir, dstDir, sources, classPath)

// compile

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Using a multi-result function as an argument to
// append should compile successfully. Previously there
// was a missing *int -> interface{} conversion that caused
// the compiler to ICE.

package p

func f() ([]interface{}, *int) {
	return nil, nil
}

 */

package org.gradle.api.internal.tasks.compile


import spock.lang.Specification
import spock.lang.Subject

import javax.tools.JavaCompiler

class JdkToolsTest extends Specification {
    @Subject
    JdkTools current = new JdkTools([])

    def "can get java compiler"() {
        def compiler = current.systemJavaCompiler

        expect:
        compiler instanceof JavaCompiler

        buildFile << newSourceSet("main2")
    }

    String compileTaskPath(String sourceSet) {
        if (sourceSet == "main") {
            return ":compile${component.languageName.capitalize()}"
        } else {
            return ":compile${sourceSet.capitalize()}${component.languageName.capitalize()}"
        }
    }

# It's absurd, but builds with -compiler=gccgo used to fail to build module m.
# golang.org/issue/34358

env GO111MODULE=off

[short] skip
[cross] skip # gccgo can't necessarily cross-compile

cd m
go build
exists m$GOEXE
rm m$GOEXE
[exec:gccgo] go build -compiler=gccgo
[exec:gccgo] exists m$GOEXE

-- m/go.mod --
module m
-- m/main.go --
package main

env GOCACHE=$WORK/gocache
mkdir $GOCACHE

# Building trivial non-main package should run compiler the first time.
go build -x lib.go
stderr '(compile|gccgo)( |\.exe).*lib\.go'

# ... but not again ...
go build -x lib.go
! stderr '(compile|gccgo)( |\.exe).*lib\.go'

# ... unless we use -a.
go build -a -x lib.go
stderr '(compile|gccgo)( |\.exe)'

-- lib.go --

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.java.compile.jpms.compile

import org.gradle.java.compile.jpms.AbstractJavaModuleCompileIntegrationTest
import org.gradle.test.precondition.TestPrecondition
import org.gradle.test.preconditions.UnitTestPreconditions

        then:
        normalized == expected
    }

    def "successfully normalizes Scala compiler warning"() {
        given:
        String input = """
> Task :app:compileJava NO-SOURCE
> Task :app:compileScala
[Warn] : -target is deprecated: Use -release instead to compile against the correct platform API.
one warning found

> Task :app:processResources NO-SOURCE
> Task :app:classes