! go list ./p
stderr '^p[/\\]b.go:2:2: expected ''package'', found ''EOF''$'
! go list -f '{{range .Imports}}{{.}} {{end}}' ./p
stderr '^p[/\\]b.go:2:2: expected ''package'', found ''EOF''$'
! go list -test ./t
stderr '^go: can''t load test package: t[/\\]t_test.go:8:1: expected declaration, found ʕ'
! go list -test -f '{{range .Imports}}{{.}} {{end}}' ./t
stderr '^go: can''t load test package: t[/\\]t_test.go:8:1: expected declaration, found ʕ'

cmp stderr wanterr.txt

! go list -json=ImportPath -deps -test ./p
cmp stderr wanterr.txt

-- wanterr.txt --
go: can't load test package: package example/p
	imports example/q
	imports example/r
	imports example/p: import cycle not allowed in test
-- go.mod --
module example
go 1.20
-- p/p.go --
package p
-- p/p_test.go --
package p
import "example/q"
-- q/q.go --
package q

            import ${DefaultTask.name};
            import ${ExecOperations.name};
            import ${Inject.name};
            import ${TaskAction.name};
            ${snippets.imports}

            public abstract class SneakyTask extends DefaultTask {
                @Inject
                protected abstract ExecOperations getExecOperations();

                public SneakyTask() {

# module does not contain a package.
# TODO(#26909): Ideally these errors should include line numbers for the imports within the main module.
cd fail
! go mod tidy
stderr '^go: localhost.fail imports\n\tw: module w@latest found \(v0.0.0-00010101000000-000000000000, replaced by ../w\), but does not contain package w$'
stderr '^go: localhost.fail imports\n\tnonexist: nonexist@v0.1.0: replacement directory ../nonexist does not exist$'

-- go.mod --

    firScope: FirAbstractStarImportingScope,
    private val analysisSession: KaFirSession,
) : KaFirBasedScope<FirAbstractStarImportingScope>(firScope, analysisSession.firSymbolBuilder) {

    private val imports: List<StarImport> by cached {
        firScope.starImports.map { import ->
            StarImport(
                import.packageFqName,
                import.relativeParentClassName,

		if !ok || d.Tok != token.IMPORT {
			// Not an import declaration, so we're done.
			// Imports are always first.
			return false
		}
		if d.Lparen.IsValid() {
			// For now assume all grouped imports are unsorted.
			// TODO(gri) Should check if they are sorted already.
			return true
		}
		// Ungrouped imports are sorted by default.
	}
	return false

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

//go:build unix || windows

// Export guts for testing on posix.
// Since testing imports os and os imports internal/poll,
// the internal/poll tests can not be in package poll.

package poll

func (fd *FD) EOFError(n int, err error) error {
	return fd.eofError(n, err)

	}

	// import go/internal/gcimporter which imports go/types partially
	fset := token.NewFileSet()
	imports := make(map[string]*types.Package)
	_, err := Import(fset, imports, "go/internal/gcimporter", ".", nil)
	if err != nil {
		t.Fatal(err)
	}

	// look for go/types package
	var goTypesPkg *types.Package
	for path, pkg := range imports {
		if path == "go/types" {
			goTypesPkg = pkg
			break

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

// Export guts for testing.
// Since testing imports os and os imports internal/poll,
// the internal/poll tests can not be in package poll.

package poll

var Consume = consume

type XFDMutex struct {
	fdMutex
}

func (mu *XFDMutex) Incref() bool {
	return mu.incref()
}

	Run(stop <-chan struct{})
}

// DelayedFilter exposes an interface for a filter create delayed informers, which start
// once the underlying resource is available. See kclient.NewDelayedInformer.
type DelayedFilter interface {
	HasSynced() bool
	KnownOrCallback(f func(stop <-chan struct{})) bool
}

// WriteAPI exposes a generic API for a client go type for write operations.