func TestXxx(*testing.T)

package main

import "testing"

func add(a, b int) int {
	return a + b
}

func TestAdd(t *testing.T) {
	type args struct {
		a int
		b int
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		{
			name: "normal",
			args: args{a: 1, b: 2},
			want: 3,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := add(tt.args.a, tt.args.b); got != tt.want {
				t.Errorf("add() = %v, want %v", got, tt.want)
			}
		})
	}
}

func add(a, b int) int {
	return a + b
}

func TestAdd(t *testing.T) {
	if add(1, 2) != 3 {
		t.Errorf("add() = %v, want %v", add(1, 2), 3)
	}
}

func TestAdd(t *testing.T) {
	type args struct {
		a int
		b int
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		{name: "fail", args: args{a: 1, b: 2}, want: 30},
		{name: "normal", args: args{a: 1, b: 2}, want: 3},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// t.Fatalf でテストが失敗した場合でもクリーンアップ処理は呼び出される
			t.Cleanup(func() {
				t.Log("cleanup!")
			})

			// t.Fatalf でテストが失敗した場合でも defer の処理は呼び出される
			defer t.Log("defer!")

			if got := add(tt.args.a, tt.args.b); got != tt.want {
				t.Fatalf("add() = %v, want %v", got, tt.want)
			}
			// t.Fatalf でテストが失敗した場合は以下は呼び出されない
			t.Log("after add() ...")
		})
	}
}

func add(a, b int) int {
	time.Sleep(365 * 24 * time.Hour)
	return a + b
}

			b: 2,
		},
		want: 3,
	},
}
for _, tt := range tests {
	t.Run(tt.name, func(t *testing.T) {
		// 以下を追加
		// ---------------------------------
		if testing.Short() {
			t.Skip("skipping test in short mode.")
		}
		// ---------------------------------
		if got := add(tt.args.a, tt.args.b); got != tt.want {
			t.Errorf("add() = %v, want %v", got, tt.want)
		}
	})
}

func TestReadOnlyWriteFile(t *testing.T) {
	if os.Getuid() == 0 {
		t.Skipf("Root can write to read-only files anyway, so skip the read-only test.")
	}

    // ...

func add(a, b int) int {
	time.Sleep(time.Duration(a+b) * time.Second)

	return a + b
}

func Test_add(t *testing.T) {
	type args struct {
		a int
		b int
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		{"normal_1", args{1, 2}, 3},
		{"normal_2", args{2, 3}, 5},
		{"normal_3", args{3, 4}, 7},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := add(tt.args.a, tt.args.b); got != tt.want {
				t.Errorf("add() = %v, want %v", got, tt.want)
			}
		})
	}
}

for _, tt := range tests {
	t.Run(tt.name, func(t *testing.T) {
		// 以下を追加
		// -----------
		t.Parallel()
		// -----------
		if got := add(tt.args.a, tt.args.b); got != tt.want {
			t.Errorf("add() = %v, want %v", got, tt.want)
		}
	})
}

func f() {
	fmt.Println("なんらかの処理")
}

func Test_f(t *testing.T) {
	f()
}

func TestMain(m *testing.M) {
	fmt.Println("前処理")
	m.Run()
    fmt.Println("後処理")
}

func TempFile(t *testing.T) (*os.File, func()) {
	t.Helper()

	file, err := os.CreateTemp("", "test")
	if err != nil {
		t.Fatal(err)
	}

	cleanup := func() {
		if err := os.Remove(file.Name()); err != nil {
			t.Fatal(err)
		}

		if err := file.Close(); err != nil {
			t.Fatal(err)
		}
	}

	return file, cleanup
}

file, cleanup := testutil.TempFile(t)
defer cleanup()

func TempFile(t *testing.T) *os.File {
	t.Helper()

	file, err := os.CreateTemp("", "test")
	if err != nil {
		t.Fatal(err)
	}

	t.Cleanup(func() {
		if err := os.Remove(file.Name()); err != nil {
			t.Fatal(err)
		}

		if err := file.Close(); err != nil {
			t.Fatal(err)
		}
	})

	return file
}

func TestBoringASN1Marshal(t *testing.T) {
	t.Setenv("GODEBUG", "rsa1024min=0")

	k, err := GenerateKey(rand.Reader, 128)
	if err != nil {
		t.Fatal(err)
	}
	_, err = asn1.Marshal(k.PublicKey)
	if err != nil {
		t.Fatal(err)
	}
}

func TestAdd(t *testing.T) {
	type args struct {
		a int
		b int
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		{name: "fail", args: args{a: 1, b: 2}, want: 30},
		{name: "normal", args: args{a: 1, b: 2}, want: 3},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := add(tt.args.a, tt.args.b); got != tt.want {
				t.Errorf("add() = %v, want %v", got, tt.want)
			}
		})
	}
}

go test io/... -run Pipe -count=1
ok      io      0.304s
ok      io/ioutil       0.563s [no tests to run]

...

go test io/... -run Pipe -count=1
ok      io      0.314s
ok      io/ioutil       0.576s [no tests to run]

...

go test io/... -run Pipe -count=1
ok      io      0.321s
ok      io/ioutil       0.575s [no tests to run]

func TestTempDir(t *testing.T) {
	tmpDir := t.TempDir()

	f := filepath.Join(tmpDir, "sample.txt")
	err := os.WriteFile(f, []byte("hoge"), 0666)
	if err != nil {
		t.Fatal(err)
	}

	t.Logf("tmpFilePath = %s", f)
}

wantForm := url.Values{
	"language": []string{"Go"},
	"name":     []string{"gopher"},
	"skill":    []string{"go-ing"},
	"field1":   []string{"value1"},
	"field2":   []string{"initial-value2", "value2"},
}
if !reflect.DeepEqual(req.Form, wantForm) {
	t.Fatalf("req.Form = %v, want %v", req.Form, wantForm)
}

type (
	Gateway struct {
		SSID      string
		IPAddress net.IP
		NetMask   net.IPMask
		Clients   []Client
	}
	Client struct {
		Hostname  string
		IPAddress net.IP
		LastSeen  time.Time
	}
)

func MakeGatewayInfo() (x, y Gateway) {
	x = Gateway{
		SSID:      "CoffeeShopWiFi",
		IPAddress: net.IPv4(192, 168, 0, 1),
		NetMask:   net.IPv4Mask(255, 255, 0, 0),
		Clients: []Client{{
			Hostname:  "ristretto",
			IPAddress: net.IPv4(192, 168, 0, 116),
		}, {
			Hostname:  "aribica",
			IPAddress: net.IPv4(192, 168, 0, 104),
			LastSeen:  time.Date(2009, time.November, 10, 23, 6, 32, 0, time.UTC),
		}, {
			Hostname:  "macchiato",
			IPAddress: net.IPv4(192, 168, 0, 153),
			LastSeen:  time.Date(2009, time.November, 10, 23, 39, 43, 0, time.UTC),
		}, {
			Hostname:  "espresso",
			IPAddress: net.IPv4(192, 168, 0, 121),
		}, {
			Hostname:  "latte",
			IPAddress: net.IPv4(192, 168, 0, 219),
			LastSeen:  time.Date(2009, time.November, 10, 23, 0, 23, 0, time.UTC),
		}, {
			Hostname:  "americano",
			IPAddress: net.IPv4(192, 168, 0, 188),
			LastSeen:  time.Date(2009, time.November, 10, 23, 3, 5, 0, time.UTC),
		}},
	}
	y = Gateway{
		SSID:      "CoffeeShopWiFi",
		IPAddress: net.IPv4(192, 168, 0, 2),
		NetMask:   net.IPv4Mask(255, 255, 0, 0),
		Clients: []Client{{
			Hostname:  "ristretto",
			IPAddress: net.IPv4(192, 168, 0, 116),
		}, {
			Hostname:  "aribica",
			IPAddress: net.IPv4(192, 168, 0, 104),
			LastSeen:  time.Date(2009, time.November, 10, 23, 6, 32, 0, time.UTC),
		}, {
			Hostname:  "macchiato",
			IPAddress: net.IPv4(192, 168, 0, 153),
			LastSeen:  time.Date(2009, time.November, 10, 23, 39, 43, 0, time.UTC),
		}, {
			Hostname:  "espresso",
			IPAddress: net.IPv4(192, 168, 0, 121),
		}, {
			Hostname:  "latte",
			IPAddress: net.IPv4(192, 168, 0, 221),
			LastSeen:  time.Date(2009, time.November, 10, 23, 0, 23, 0, time.UTC),
		}},
	}
	return x, y
}

func TestMakeGatewayInfoDeepEqual(t *testing.T) {
	got, want := MakeGatewayInfo()
	if !reflect.DeepEqual(got, want) {
		t.Errorf("MakeGatewayInfo() got = %v, want %v", got, want)
	}
}

func TestMakeGatewayInfoGoCmp(t *testing.T) {
	got, want := MakeGatewayInfo()
	if diff := cmp.Diff(want, got); diff != "" {
		t.Errorf("MakeGatewayInfo() mismatch (-want +got):\n%s", diff)
	}
}

func TestX(t *testing.T) {
	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		fmt.Fprintln(w, "Hello, client")
	}))
	defer ts.Close()

	res, err := http.Get(ts.URL)
	if err != nil {
		t.Error(err)
	}

	got, err := io.ReadAll(res.Body)
	res.Body.Close()

	// API からのレスポンスを用いてなんならの処理をする

	if res.StatusCode != 200 {
		t.Errorf("GET %s: expected status code = %d; got %d", ts.URL, 200, res.StatusCode)
	}
	if string(got) != "Hello, client\n" {
		t.Errorf("expected body %v; got %v", "Hello, client", string(got))
	}
}

func setup() (client *Client, mux *http.ServeMux, serverURL string, teardown func()) {
	mux = http.NewServeMux()

	apiHandler := http.NewServeMux()
	apiHandler.Handle(baseURLPath+"/", http.StripPrefix(baseURLPath, mux))

	// ...

	server := httptest.NewServer(apiHandler)

	client = NewClient(nil)
	url, _ := url.Parse(server.URL + baseURLPath + "/")
	client.BaseURL = url
	client.UploadURL = url

	return client, mux, server.URL, server.Close
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
	w.WriteHeader(http.StatusOK)
	w.Write([]byte("hello world!"))
}

import (
	"io/ioutil"
	"net/http/httptest"
	"testing"
)

func TestHelloHandler(t *testing.T) {
	r := httptest.NewRequest("GET", "/dummy", nil)
	w := httptest.NewRecorder()

	helloHandler(w, r)

	resp := w.Result()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		t.Errorf("cannot read test response: %v", err)
	}

	if resp.StatusCode != 200 {
		t.Errorf("got = %d, want = 200", resp.StatusCode)
	}

	if string(body) != "hello world!" {
		t.Errorf("got = %s, want = hello world!", body)
	}
}

package main

import (
	"fmt"
	"math/rand"
	"testing"
	"time"
)

func TestFoo(te *testing.T) {
	start := time.Now()
	var t *time.Timer
	t = time.AfterFunc(randomDuration(), func() {
		fmt.Println(time.Now().Sub(start))
		t.Reset(randomDuration())
	})
	time.Sleep(5 * time.Second)
}

func randomDuration() time.Duration {
	return time.Duration(rand.Int63n(1e9))
}

func mustUrlParse(t *testing.T, s string) *url.URL {
	t.Helper()
	u, err := url.Parse(s)
	if err != nil {
		t.Fatal(err)
	}
	return u
}

func TestX(t *testing.T) {
	type args struct {
		str string
	}
	tests := []struct {
		name string
		args args
		want int
	}{
		{"normal1", args{"http://example.com/"}, 0},
		{"normal2", args{"%zzzzz" /* error occured */}, 1},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			url := mustUrlParse(t, tt.args.str)

			// 何らかの処理をしてテストする
		})
	}
}

package mypkg

// ...

// mypkg ディレクトリにあるテストファイルでも _test を付けたパッケージ名を混在できる
package mypkg_test

// ...

// +build integration

package x

import (
	"testing"
)

func TestX(t *testing.T) {

	// connecting server and some processing and so on...

	t.Log("run integration test")
}

// Copyright 2019 Google Inc. All Rights Reserved.
// This file is available under the Apache license.
// +build integration

package mtail_test

import (
	"os"
	"path"
	"testing"
	"time"

	"github.com/google/mtail/internal/mtail"
	"github.com/google/mtail/internal/testutil"
)

func TestNewProg(t *testing.T) {
	tmpDir, rmTmpDir := testutil.TestTempDir(t)
	defer rmTmpDir()

	logDir := path.Join(tmpDir, "logs")
	progDir := path.Join(tmpDir, "progs")
	err := os.Mkdir(logDir, 0700)
	if err != nil {
		t.Fatal(err)
	}
	err = os.Mkdir(progDir, 0700)
	if err != nil {
		t.Fatal(err)
	}

	m, stopM := mtail.TestStartServer(t, 0, false, mtail.ProgramPath(progDir), mtail.LogPathPatterns(logDir+"/*"))
	defer stopM()

	startProgLoadsTotal := mtail.TestGetMetric(t, m.Addr(), "prog_loads_total").(map[string]interface{})

	testutil.TestOpenFile(t, progDir+"/nocode.mtail")
	time.Sleep(time.Second)

	progLoadsTotal := mtail.TestGetMetric(t, m.Addr(), "prog_loads_total").(map[string]interface{})

	mtail.ExpectMetricDelta(t, progLoadsTotal["nocode.mtail"], startProgLoadsTotal["nocode.mtail"], 1)

}

type DataStore interface {
	FindUser(ctx context.Context, id int) (*User, error)
	CreateUser(ctx context.Context, name string) error
}

type User struct {
	id   int
	name string
}

type UserDataStore struct {
	*sql.DB
}

// DataStore のインターフェースを返すのがポイント
func NewDataStore(db *sql.DB) DataStore {
	return &UserDataStore{db}
}

func (u *UserDataStore) FindUser(ctx context.Context, id int) (*User, error) {
	var user *User
	row := u.QueryRowContext(context.Background(), `SELECT * FROM user WHERE userId = ?`, id)
	if err := row.Scan(&user); err != nil {
		return nil, err
	}
	return user, nil
}

func (u *UserDataStore) CreateUser(ctx context.Context, name string) error {
	// ...
	return nil
}

type MockUserDataStore struct{}

func NewMockDataStore() DataStore {
	return &MockUserDataStore{}
}

func (m *MockUserDataStore) FindUser(ctx context.Context, id int) (*User, error) {
	return &User{
		id:   1,
		name: "test user",
	}, nil
}

func (m *MockUserDataStore) CreateUser(ctx context.Context, name string) error {
	fmt.Println("create user. dummy")
	return nil
}

func TestXXX(t *testing.T) {
	storage := NewMockDataStore()
	// ...
	user, err = storage.FindUser(context.TODO(), 1)
	// ...
}

import (
	"context"
	"testing"

	"github.com/stretchr/testify/require"
	"github.com/testcontainers/testcontainers-go"
	"github.com/testcontainers/testcontainers-go/wait"
)

func TestWithRedis(t *testing.T) {
	ctx := context.Background()
	req := testcontainers.ContainerRequest{
		Image:        "redis:latest",
		ExposedPorts: []string{"6379/tcp"},
		WaitingFor:   wait.ForLog("Ready to accept connections"),
	}
	redisC, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
		ContainerRequest: req,
		Started:          true,
	})
	testcontainers.CleanupContainer(t, redisC)
	require.NoError(t, err)
}

func X(send chan struct{}) {
	go func() {
		for {
			select {
			// チャネルになんらかの値が書き込まれない or チャネルがクローズされない限り
			// ブロックされて、ゴルーチンリークになる
			case <-send:
				return
			}
		}
	}()
}

func TestDoLeak(t *testing.T) {
	closedchan := make(chan struct{})
	close(closedchan)

	tests := []struct {
		name string
		ch   chan struct{}
	}{
		{
			name: "not leak",
			// クローズされているチャネルを渡す
			ch:   closedchan,
		},
		{
			name: "leak",
			ch:   make(chan struct{}),
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			defer goleak.VerifyNone(t)
			X(tt.ch)
		})
	}
}