import gradlebuild.integrationtests.addDependenciesAndConfigurations
import gradlebuild.integrationtests.tasks.SmokeIdeTest

plugins {
    id("gradlebuild.internal.java")
}

description = "Tests are checking Gradle behavior during IDE synchronization process"

val smokeIdeTestSourceSet = sourceSets.create("smokeIdeTest") {
    compileClasspath += sourceSets.main.get().output
    runtimeClasspath += sourceSets.main.get().output
}

# Check to see that the distribution is not stale
# even when it's been moved to a different directory.
# Simulate that by creating a symlink to the tree.

# We use net instead of std because stale std has
# the behavior of checking that all std targets
# are stale rather than any of them.

[!symlink] skip
[short] skip

go build net
! stale net

symlink new -> $GOROOT
env OLDGOROOT=$GOROOT
env GOROOT=$WORK${/}gopath${/}src${/}new

        toolingApi.withConnection { connection -> connection.newBuild().run() }

        then:
        noExceptionThrown()
    }

    def "tooling api restores java logging at end of build"() {
        //(SF) checking if the logger level was not overridden.
        //this gives some confidence that the LogManager was not reset
        given:
        LogManager.getLogManager().getLogger("").setLevel(OFF);
        buildFile << "task hey"

    static void beforeBuild(File workingDir) {
        workingDir.listFiles().findAll { new File(it, "settings.gradle").exists() }.forEach { projectDir ->
            // Workaround for Android Gradle plugin checking for the presence of these directories at configuration time,
            // which invalidates configuration cache if their presence changes. Create these directories before the first build.

// errorcheck

// Copyright 2020 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.

// Basic type parameter list type-checking (not syntax) errors.

package tparam1

// The predeclared identifier "any" may be used in place of interface{}.
var _ any

func _(_ any)

type _[_ any] struct{}

const N = 10

type (

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

// Issue 20298: "imported and not used" error report order was non-deterministic.
// This test works by limiting the number of errors (-e=0)
// and checking that the errors are all at the beginning.

package p

import (
	"bufio"       // ERROR "imported and not used"
	"bytes"       // ERROR "imported and not used"
	"crypto/x509" // ERROR "imported and not used"

	Col1  uint16 // Column number for block end.
	Stmts uint16 // Number of statements included in this block.
}

var cover Cover

// Cover records information about test coverage checking.
// NOTE: This struct is internal to the testing infrastructure and may change.
// It is not covered (yet) by the Go 1 compatibility guidelines.
type Cover struct {
	Mode            string

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

// The parser no longer parses type parameters for methods.
// In the past, type checking the code below led to a crash (#50427).

type T interface{ m[ /* ERROR "must have no type parameters" */ P any]() }

func _(t T) {

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// Package healthz implements basic http server health checking.
// Usage:
//
//	import "k8s.io/apiserver/pkg/server/healthz"
//	healthz.InstallHandler(mux)

*/
import "C"

import (
	"testing"
	"unsafe"
)

func test42018(t *testing.T) {
	// Test that Windows handles are marked go:notinheap, by growing the
	// stack and checking for pointer adjustments. Trick from
	// test/fixedbugs/issue40954.go.
	var i int
	handle := C.HANDLE(unsafe.Pointer(uintptr(unsafe.Pointer(&i))))
	recurseHANDLE(100, handle, uintptr(unsafe.Pointer(&i)))