type Pkg struct {
	ImportPath string
	Dir        string
	Error      *struct {
		Err string
	}
}

func findPkgs(profiles []*cover.Profile) (map[string]*Pkg, error) {
	// Run go list to find the location of every package we care about.
	pkgs := make(map[string]*Pkg)
	var list []string
	for _, profile := range profiles {
		if strings.HasPrefix(profile.FileName, ".") || filepath.IsAbs(profile.FileName) {

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

package main

import (
	"cmd/go/internal/base"
	"os"
	"strings"
	"testing"
)

func TestChdir(t *testing.T) {
	// We want -C to apply to every go subcommand.
	// Test that every command either has a -C flag registered
	// or has CustomFlags set. In the latter case, the command
	// must be explicitly tested in TestScript/chdir.
	script, err := os.ReadFile("testdata/script/chdir.txt")

package internal

import (
	"sync"
	"time"
)

// AtMostEvery will never run the method more than once every specified
// duration.
type AtMostEvery struct {
	delay    time.Duration
	lastCall time.Time
	mutex    sync.Mutex
}

// NewAtMostEvery creates a new AtMostEvery, that will run the method at
// most every given duration.
func NewAtMostEvery(delay time.Duration) *AtMostEvery {
	return &AtMostEvery{
		delay: delay,

                .withTasks(":sub1:exec", ":sub2:exec")
                .run()
        }

        then: "invalid JVM installation warning should be printed in every build"
        results.size() == 2
        results.every { result ->
            def expectedErrorMessages = [invalidJdkHome1, invalidJdkHome2].collect {

			ctx.Fatal(err)
		}
	}
}

func (t *T) hasSourceSetup() bool {
	return len(t.sourceDeploymentSetup) > 0
}

// SetupForPair runs the given function for every source instance in every cluster in combination with every
// destination service.
//
// Example of how long this setup lasts before the given context is cleaned up:
//   - a/to_b/from_cluster-1
//   - a/to_b/from_cluster-2
//   - cleanup...

        when:
        BuildInvocations model = withConnection { connection ->
            connection.getModel(BuildInvocations)
        }

        then:
        model.tasks.every { Task t -> publicTasks.contains(t.name) == t.public }
        model.taskSelectors.every { TaskSelector ts -> publicSelectors.contains(ts.name) == ts.public }
    }

# Test required and embedded body parameters with no bodies sent
def test_post_body_example():
    response = client.put(
        "/items/5",
        json={
            "name": "Foo",
            "description": "A very nice Item",
            "price": 35.4,
            "tax": 3.2,
        },
    )
    assert response.status_code == 200


def test_openapi_schema():
    response = client.get("/openapi.json")

// associated with f2

// f2
func f2() {
}

func f3() {
	i := 1 /* 1 */ + 2 // addition
	_ = i
}

// the very last comment
`

// res maps a key of the form "line number: node type"
// to the associated comments' text.
var res = map[string]string{
	" 5: *ast.File":       "the very first comment\npackage p\n",
	" 5: *ast.Ident":      " the name is p\n",
	" 8: *ast.GenDecl":    "imports\n",

# Test required and embedded body parameters with no bodies sent
def test_post_body_example():
    response = client.put(
        "/items/5",
        json={
            "name": "Foo",
            "description": "A very nice Item",
            "price": 35.4,
            "tax": 3.2,
        },
    )
    assert response.status_code == 200


def test_openapi_schema():
    response = client.get("/openapi.json")

        generatedSourceDirectories.collect { it.directory } == [file('foo')]
        generatedSourceDirectories.every { contentRoot.sourceDirectories.contains(it) }
        generatedTestDirectories.every { contentRoot.testDirectories.contains(it) }
    }