f2(x /* ERROR "type func(interface{m(int)}) of x does not match func(I[T]) (cannot infer T)" */)
}

func f3[T any](func(I[T])) {}

func _() {
	var x func(I[int])
	f3(x) // but this is correct: I[T] and I[int] can be made identical with T == int
}

func f4[T any]([10]I[T]) {}

func _() {
	var x [10]interface{ I[int] }

const (
	export checkMode = 1 << iota
	rawFormat
	normNumber
	idempotent
	allowTypeParams
)

// format parses src, prints the corresponding AST, verifies the resulting
// src is syntactically correct, and returns the resulting src or an error
// if any.
func format(src []byte, mode checkMode) ([]byte, error) {
	// parse src
	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
	if err != nil {

        def pmdTask = project.tasks.getByName("pmdMain")
        expect:
        pmdTask.classpath.files == (mainSourceSet.output + mainSourceSet.compileClasspath).files
    }

    def "tool configuration has correct attributes"() {
        expect:
        with(project.configurations.pmd.attributes) {
            assert getAttribute(Category.CATEGORY_ATTRIBUTE).name == Category.LIBRARY

    }

    def "build succeeds if test class is only available in one test task"() {
        given:
        file("src/moreTests/java/more/MoreTest.java") << """
            package more;
            public class MoreTest {
                @org.junit.Test public void bar() throws Exception {
                     org.junit.Assert.assertEquals(2, 2);
                }
            }
        """

import java.util.concurrent.Executors
import java.util.concurrent.TimeUnit

class DefaultFileSystemAccessConcurrencyTest extends AbstractFileSystemAccessTest {

    def "parallel invalidation yields correct results"() {
        def dir = temporaryFolder.createDir("some/deep/hierarchy")
        (1..1000).each {
            def subdir = dir.file(it)
            subdir.file("in-dir.txt").createFile()
        }

// generating an instruction with DS relocation for go.strings
// since their alignment is not known until link time. 

// This problem only affects go.string since other types have
// correct alignment.

const (
        LevelBad Level = "badvals"
        LevelNone Level = "No"
        LevelMetadata Level = "Metadata"
        LevelRequest Level = "Request"

              TypeID::get<FallbackAsyncDialect>()) {
  context->getOrLoadDialect<tfrt::fallback::FallbackDialect>();
  context->getOrLoadDialect<compiler::TFRTDialect>();
  context->getOrLoadDialect<corert::CoreRTDialect>();

  allowUnknownTypes();

  allowUnknownOperations();

  addInterfaces<FallbackInlinerInterface>();

  addOperations<
#define GET_OP_LIST

/*
Parenthesized type switch expressions originally
accepted by gofmt must continue to be rewritten
into the correct unparenthesized form.

Only type-switches that didn't declare a variable
in the type switch type assertion and which
contained only "expression-like" (named) types in their
cases were permitted to have their type assertion parenthesized
by go/parser (due to a weak predicate in the parser). All others

// Ideally these functions would be defined in a test file, but go test doesn't
// allow CGO in tests. The build tag should ensure either way that these
// functions will not end up in the package.

// TODO: Ensure that the correct ICU version is set.

/*
#cgo LDFLAGS: -licui18n.57 -licuuc.57
#include <stdlib.h>
#include <unicode/ustring.h>
#include <unicode/utypes.h>
#include <unicode/localpointer.h>
#include <unicode/ucasemap.h>
*/

// catch this.
// NOTE: this program assumes comparing instance of T and T's
// underlying []byte will make gc emit calls to runtime.equal,
// and if gc optimizes this case, then the test will no longer
// be correct (in the sense that it no longer tests runtime.equal).

package main

import (
	"bytes"
	"fmt"
	"strconv"
	"strings"
)

const ntest = 1024

func main() {
	var decls, calls bytes.Buffer