module example.net/b

go 1.16

require example.net/a v0.1.0
-- b10/b.go --
package b
-- b10/b_test.go --
package b_test

import _ "example.net/a"

-- b11/go.mod --
module example.net/b

go 1.16

require example.net/a v0.2.0
-- b11/b.go --
package b
-- b11/b_test.go --
package b_test

import _ "example.net/a"

-- b12/go.mod --
module example.net/b

go 1.16

		pmain = nil
	}
	if ptest.Error != nil || ptest.Incomplete {
		ptest = nil
	}
	if pxtest != nil && (pxtest.Error != nil || pxtest.Incomplete) {
		pxtest = nil
	}
	return pmain, ptest, pxtest, err
}

// TestPackagesAndErrors returns three packages:
//   - pmain, the package main corresponding to the test binary (running tests in ptest and pxtest).

env GO111MODULE=off

# issue 25980: crash in go list -e -test
go list -e -test -deps -f '{{.Error}}' p
stdout '^p[/\\]d_test.go:2:8: cannot find package "d" in any of:'

-- p/d.go --
package d
-- p/d_test.go --
package d_test

# Workaround for issue 64014 -- for the portion of this test that
# verifies that caching works correctly, the cache should theoretically
# always behave reliably/deterministically, however if other tests are
# concurrently accessing the cache while this test is running, it can
# lead to cache lookup failures, which manifest as test failures here.
# To avoid such flakes, use a separate isolated GOCACHE for this test.
env GOCACHE=$WORK/cache

	// except for any used by the network poller.
	for fd := uintptr(4); fd <= 100; fd++ {
		if poll.IsPollDescriptor(fd) {
			continue
		}

		if !fdtest.Exists(fd) {
			continue
		}

		fmt.Printf("leaked parent file. fdtest.Exists(%d) got true want false\n", fd)

		fdfile := fmt.Sprintf("/proc/self/fd/%d", fd)
		link, err := os.Readlink(fdfile)
		fmt.Printf("readlink(%q) = %q, %v\n", fdfile, link, err)

# issue 26880: list with tests has wrong variant in imports
go list -test -f '{{.ImportPath}}:{{with .Imports}} {{join . ", "}}{{end}}' a b
cmp stdout imports.txt

-- a/a.go --
package a; import _ "b"
-- b/b.go --
package b
-- b/b_test.go --
package b
-- b/b_x_test.go --
package b_test; import _ "a"

-- imports.txt --
a: b
b:
b.test: b [b.test], b_test [b.test], os, reflect, testing, testing/internal/testdeps
b [b.test]:

# This test demonstrates dependency resolution when the main module imports a
# new package from a previously-test-only dependency.
#
# When lazy loading is active, the loader will not load dependencies of any
# module whose packages are *only* imported by tests outside the main module. If
# the main module is changed to import a package from such a module, the
# dependencies of that module will need to be reloaded.

# The import graph used in this test looks like:

//
// The Google C++ Testing Framework (Google Test)
//
// This header file defines the public API for death tests.  It is
// #included by gtest.h so a user doesn't need to include this
// directly.

#ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_
#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_

#include "gtest/internal/gtest-death-test-internal.h"

namespace testing {

#endif  // 0

#include "gtest/internal/gtest-port.h"
#include "gtest/internal/gtest-type-util.h"

// Implements typed tests.

#if GTEST_HAS_TYPED_TEST

// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE.
//
// Expands to the name of the typedef for the type parameters of the
// given test case.
# define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_

env GO111MODULE=off
go build ./...
! stdout .
go test ./...
stdout '^ok'
go list ./...
stdout 'pkgs$'
stdout 'pkgs/a'

-- pkgs/go.mod --
module pkgs

go 1.16
-- pkgs/a.go --
package x
-- pkgs/a_test.go --
package x_test

import "testing"

func TestX(t *testing.T) {
}
-- pkgs/a/a.go --
package a
-- pkgs/a/a_test.go --
package a_test

import "testing"

func TestA(t *testing.T) {