# This file demonstrates the effect of lazy loading on the selected
# versions of test dependencies.

# The package import graph used in this test looks like:
#
# m ---- a
#  \     |
#   \    a_test ---- b
#    \               |
#     x              b_test
#     |                    \
#     x_test -------------- c
#
# And the module dependency graph looks like:
#
# m -- a.1 -- b.1 -- c.2
#  \
#   x.1 ------------ c.1

# Control case: in Go 1.15, the version of c imported by 'go test x' is the
# version required by module b, even though b_test is not relevant to the main
# module. (The main module imports a, and a_test imports b, but all of the
# packages and tests in the main module can be built without b.)

go list -m c
stdout '^c v0.2.0 '

[!short] go test -v x
[!short] stdout ' c v0.2.0$'

# With lazy loading, the go.mod requirements are the same,
# but the irrelevant dependency on c v0.2.0 should be pruned out,
# leaving only the relevant dependency on c v0.1.0.

go mod edit -go=1.17
go list -m c
stdout '^c v0.1.0'

[!short] go test -v x
[!short] stdout ' c v0.1.0$'

-- m.go --
package m

import (
	_ "a"
	_ "x"
)
-- go.mod --
module m

go 1.15

require (
	a v0.1.0
	x v0.1.0
)

replace (
	a v0.1.0 => ./a1
	b v0.1.0 => ./b1
	c v0.1.0 => ./c1
	c v0.2.0 => ./c2
	x v0.1.0 => ./x1
)
-- a1/go.mod --
module a

go 1.17

require b v0.1.0
-- a1/a.go --
package a
-- a1/a_test.go --
package a_test

import _ "b"
-- b1/go.mod --
module b

go 1.17

require c v0.2.0
-- b1/b.go --
package b
-- b1/b_test.go --
package b_test

import (
	"c"
	"testing"
)

func TestCVersion(t *testing.T) {
	t.Log(c.Version)
}
-- c1/go.mod --
module c

go 1.17
-- c1/c.go --
package c

const Version = "v0.1.0"
-- c2/go.mod --
module c

go 1.17
-- c2/c.go --
package c

const Version = "v0.2.0"
-- x1/go.mod --
module x

go 1.17

require c v0.1.0
-- x1/x.go --
package x
-- x1/x_test.go --
package x_test

import (
	"c"
	"testing"
)

func TestCVersion(t *testing.T) {
	t.Log("c", c.Version)
}
