How to shared items in different testing files

I want to shared items in many different testing files, just like global variable but only in testing scope.

./1_test.go
./2_test.go
./3_test.go

// shared between these files
var item *test.global

Let's say the current package name is cpx, you can use the package name cpx_test for all 3 test files. Go allows 1 package (with one or more files) and 1 test package (with one or more files) in the same directory.

cpx
├── cpx.go
├── cpx_1_test.go
├── cpx_2_test.go
└── cpx_3_test.go

By using this, you can declare global variables in cpx_test scope that are only limited to the 3 test files. You should import original package in test as an external package.

import "gitlab.com/VagueCoder0to.n/Project/cpx"

Let's say we have the following snippet in cpx_1_test.go

var (
	complex1, complex2, complex3 *cpx.Complex
)

func TestAdd(t *testing.T) {
	complex1 = &cpx.Complex{
		Real: 1,
		Imag: 10,
	}

	complex2 = &cpx.Complex{
		Real: 2,
		Imag: 9,
	}

	complex3 = cpx.ComplexAdd(complex1, complex2)
}

The 3 variables can be used by other 2 files as well. But the limitations here are:

1. Testing the cpx_2_test.go and cpx_3_test.go file separately may give you false errors as the initiation of variables is done in cpx_1_test.go alone.
2. Order of test files in execution matters.

go test cpx_1_test.go cpx_2_test.go cpx_3_test.go

3. Order of test cases also matters. The test TestAdd should be tested before any other test function.

Alternatively, I use the sub-tests in use-cases, which goes against your initial idea, but it makes sense if the unit tests are related. i.e., have some similar classification, say TestOperators, with sub tests TestAdd, TestSubtract, TestMultiply, TestDivision. The testing package provides Run method on type *testing.T to define sub tests.

func TestOperators(t *testing.T) {
	var complex1, complex2, complex3 *cpx.Complex
	complex1 = &cpx.Complex{
		Real: 1,
		Imag: 10,
	}

	complex2 = &cpx.Complex{
		Real: 2,
		Imag: 9,
	}

	t.Run("TestAdd", func(t *testing.T) {
		complex3 = cpx.ComplexAdd(complex1, complex2)
		assert.NotNil(t, complex3)
	})

	t.Run("TestSubtract", func(t *testing.T) {
		complex3 = cpx.ComplexSubtract(complex1, complex2)
		// Tests here
	})

	t.Run("TestMultiply", Multiply)

	// More sub tests...

}

func Multiply(t *testing.T) {
	// Tests here
}

You may use inline anonymous functions (like in TestAdd and TestSubtract) or general test cases (as in TestMultiply). If using functions, make sure the function name (identifier) doesn't start with the work "Test". Else, go tools will consider that as a separate test case. Output will be:

go test -v ./...
?   	gitlab.com/VagueCoder0to.n/Project	[no test files]
=== RUN   TestOperators
=== RUN   TestOperators/TestAdd
=== RUN   TestOperators/TestSubtract
=== RUN   TestOperators/TestMultiply
--- PASS: TestOperators (0.00s)
    --- PASS: TestOperators/TestAdd (0.00s)
    --- PASS: TestOperators/TestSubtract (0.00s)
    --- PASS: TestOperators/TestMultiply (0.00s)
PASS
ok  	gitlab.com/VagueCoder0to.n/Project/cpx	0.004s