x < x                  // ERROR "x < x .* not used"
	x >= x                 // ERROR "x >= x .* not used"
	x > x                  // ERROR "x > x .* not used"
	*tp                    // ERROR "\*tp .* not used"
	slice[0]               // ERROR "slice\[0\] .* not used"
	m[1]                   // ERROR "m\[1\] .* not used"
	len(slice)             // ERROR "len\(slice\) .* not used"

Faseela K <******@****.***> 1686686394 +0200

"""
    }

    def "optionally shows causes"() {
        def causeCause = new RuntimeException("oops").tap { stackTrace = createCauseCauseTrace() }
        def cause = new IllegalArgumentException("ouch", causeCause).tap { stackTrace = createCauseTrace() }
        def exception = new Exception("argh", cause).tap { stackTrace = createStackTrace() }

        testLogging.showCauses >> true

# Regression test for https://go.dev/issue/64738:
# a bug in 'go run' caused flags arguments after the requested package to
# also be parsed as cmd/go flags.

        Throwable cause = causes.get(0);
        printWriter.print("Caused by: ");
        cause.printStackTrace(printWriter);
    }

    private void printMultiCauseStackTrace(PrintWriter printWriter) {
        for (int i = 0; i < causes.size(); i++) {
            Throwable cause = causes.get(i);
            printWriter.format("Cause %s: ", i + 1);
            cause.printStackTrace(printWriter);
        }

        runner.targetVersions = ['2.14']
        runner.useDaemon = true
...
        where:
        // source file change causes a single project, single source set, single file to be recompiled.
        // header file change causes a single project, two source sets, some files to be recompiled.
        // recompile all sources causes all projects, all source sets, all files to be recompiled.

	_ = t
	_ = t
}
`

func main() {
	fmt.Println("package main")
	types := []string{
		// These types always passed
		"bool", "int", "rune",
		"*int", "uintptr",
		"float32", "float64",
		"chan struct{}",
		"map[string]struct{}",
		"func()", "func(string)error",

		// These types caused compilation failures
		"complex64", "complex128",
		"struct{}", "struct{n int}", "struct{e error}", "struct{m map[string]string}",

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

// Code patterns that caused problems in the past.

package race_test

import (
	"testing"
)

type LogImpl struct {
	x int
}

func NewLog() (l LogImpl) {
	c := make(chan bool)
	go func() {
		_ = l
		c <- true
	}()
	l = LogImpl{}
	<-c
	return
}

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

// Issue 53989: the use of jump table caused a function
// from the plugin jumps in the middle of the function
// to the function with the same name in the main
// executable. As these two functions may be compiled
// differently as plugin needs to be PIC, this causes
// crash.

package main

import (
	"plugin"

	"testplugin/issue53989/p"
)

            List<Failure> causes = failure.getCauses();
            if (causes.size() == 1) {
                printRecursively("Caused by: ", prefix, failure, causes.get(0));
            } else {
                for (int i = 0; i < causes.size(); i++) {
                    printRecursively(String.format("Cause %s: ", i + 1), prefix, failure, causes.get(i));
                }
            }
        }