Пакет testing
Обзор
Пакет testing предоставляет поддержку автоматического тестирования пакетов Go. Он предназначен для использования вместе с командой "go test", которая автоматизирует выполнение функций следующего вида
func TestXxx(*testing.T)
где Xxx не начинается со строчной буквы. Имя функции служит для идентификации тестовой процедуры.
Внутри этих функций используйте T.Error, T.Fail или связанные методы, чтобы сообщить об ошибке.
Чтобы написать новый набор тестов, создайте файл с функциями TestXxx, описанными здесь, и присвойте ему имя, заканчивающееся на "_test.go". Этот файл будет исключен из обычных сборок пакета, но будет включен при запуске команды "go test".
Тестовый файл может находиться в том же пакете, что и тестируемый, или в соответствующем пакете с суффиксом "_test".
Если тестовый файл находится в том же пакете, он может обращаться к неэкспортируемым идентификаторам пакета, как в этом примере:
package abs
import "testing"
func TestAbs(t *testing.T) {
got := abs(-1)
if got != 1 {
t.Errorf("abs(-1) = %d; want 1", got)
}
}
Если файл находится в отдельном пакете "_test", тестируемый пакет необходимо импортировать явно, и можно использовать только его экспортируемые идентификаторы. Такой подход называется тестированием «черного ящика».
package abs_test
import (
"testing"
"path_to_pkg/abs"
)
func TestAbs(t *testing.T) {
got := abs.Abs(-1)
if got != 1 {
t.Errorf("Abs(-1) = %d; want 1", got)
}
}
Дополнительные сведения см. в справке go help test и go help testflag.
Бенчмарки
Функции следующего вида
func BenchmarkXxx(*testing.B)
считаются бенчмарками и выполняются командой "go test", если указан флаг -bench. Бенчмарки запускаются последовательно.
Описание флагов тестирования см. в справке go help testflag.
Пример функции бенчмарка:
func BenchmarkRandInt(b *testing.B) {
for b.Loop() {
rand.Int()
}
}
Вывод
BenchmarkRandInt-8 68453040 17.8 ns/op
означает, что тело цикла выполнилось 68453040 раз со скоростью 17.8 нс на цикл.
Измеряется только тело цикла, поэтому перед вызовом b.Loop бенчмарки могут выполнять ресурсоемкую подготовку, которая не будет учитываться при измерении:
func BenchmarkBigLen(b *testing.B) {
big := NewBig()
for b.Loop() {
big.Len()
}
}
Если бенчмарку нужно проверить производительность в параллельном режиме, можно использовать вспомогательную функцию RunParallel; такие бенчмарки предназначены для использования с флагом go test -cpu:
func BenchmarkTemplateParallel(b *testing.B) {
templ := template.Must(template.New("test").Parse("Hello, {{.}}!"))
b.RunParallel(func(pb *testing.PB) {
var buf bytes.Buffer
for pb.Next() {
buf.Reset()
templ.Execute(&buf, "World")
}
})
}
Подробная спецификация формата результатов бенчмарков приведена по адресу https://go.dev/design/14313-benchmark-format.
Для работы с результатами бенчмарков существуют стандартные инструменты в golang.org/x/perf/cmd. В частности, golang.org/x/perf/cmd/benchstat выполняет статистически надежные A/B-сравнения.
Бенчмарки в стиле b.N
До появления B.Loop бенчмарки писали в другом стиле, используя B.N. Например:
func BenchmarkRandInt(b *testing.B) {
for range b.N {
rand.Int()
}
}
В этом стиле бенчмарка функция должна выполнить целевой код b.N раз. Функция бенчмарка вызывается несколько раз, а значение b.N корректируется до тех пор, пока выполнение функции не станет достаточно длительным для надежного измерения. Это также означает, что подготовка, выполненная перед циклом, может запускаться несколько раз.
Если перед запуском бенчмарка требуется ресурсоемкая подготовка, таймер следует явно сбросить:
func BenchmarkBigLen(b *testing.B) {
big := NewBig()
b.ResetTimer()
for range b.N {
big.Len()
}
}
В новых бенчмарках предпочтительно использовать B.Loop, который надежнее и эффективнее.
Примеры
Пакет также запускает и проверяет пример кода. Функции-примеры могут содержать завершающий комментарий, начинающийся с "Output:", который при запуске тестов сравнивается со стандартным выводом функции. (При сравнении игнорируются начальные и конечные пробелы.) Примеры примеров:
func ExampleHello() {
fmt.Println("hello")
// Output: hello
}
func ExampleSalutations() {
fmt.Println("hello, and")
fmt.Println("goodbye")
// Output:
// hello, and
// goodbye
}
Префикс комментария "Unordered output:" работает так же, как "Output:", но допускает любой порядок строк:
func ExamplePerm() {
for _, value := range Perm(5) {
fmt.Println(value)
}
// Unordered output: 4
// 2
// 1
// 3
// 0
}
Функции-примеры без комментариев с ожидаемым выводом компилируются, но не выполняются.
Для объявления примеров пакета, функции F, типа T и метода M типа T используется следующее соглашение об именовании:
func Example() { ... }
func ExampleF() { ... }
func ExampleT() { ... }
func ExampleT_M() { ... }
Для пакета, типа, функции или метода можно указать несколько функций-примеров, добавив к имени уникальный суффикс. Суффикс должен начинаться со строчной буквы.
func Example_suffix() { ... }
func ExampleF_suffix() { ... }
func ExampleT_suffix() { ... }
func ExampleT_M_suffix() { ... }
Весь тестовый файл отображается как пример, если он содержит одну функцию-пример, как минимум одно другое объявление функции, типа, переменной или константы и не содержит функций тестов или бенчмарков.
Фаззинг
'go test' и пакет testing поддерживают фаззинг — метод тестирования, при котором функция вызывается со случайно сгенерированными входными данными для поиска ошибок, не предусмотренных модульными тестами.
Функции следующего вида
func FuzzXxx(*testing.F)
считаются фаззинг-тестами.
Например:
func FuzzHex(f *testing.F) {
for _, seed := range [][]byte{{}, {0}, {9}, {0xa}, {0xf}, {1, 2, 3, 4}} {
f.Add(seed)
}
f.Fuzz(func(t *testing.T, in []byte) {
enc := hex.EncodeToString(in)
out, err := hex.DecodeString(enc)
if err != nil {
t.Fatalf("%v: decode: %v", in, err)
}
if !bytes.Equal(in, out) {
t.Fatalf("%v: not equal after round trip: %v", in, out)
}
})
}
Фаззинг-тест использует начальный корпус — набор входных данных, выполняемых по умолчанию и используемых для генерации новых входных данных. Начальные данные можно зарегистрировать вызовом F.Add или сохранить в файлах каталога testdata/fuzz/<Name> (где <Name> — имя фаззинг-теста) в пакете, содержащем этот тест. Начальные данные необязательны, но при наличии набора небольших начальных данных с хорошим покрытием кода движок фаззинга может эффективнее находить ошибки. Эти данные также могут служить регрессионными тестами для ошибок, обнаруженных с помощью фаззинга.
Функция, переданная в F.Fuzz внутри фаззинг-теста, считается целевой функцией фаззинга. Целевая функция должна принимать параметр *T, а затем один или несколько параметров для случайных входных данных. Типы аргументов, переданных в F.Add, должны совпадать с типами этих параметров. Целевая функция может сообщить о найденной проблеме так же, как обычный тест: вызвав T.Fail (или любой метод, который его вызывает, например T.Error или T.Fatal) либо вызвав панику.
При включенном фаззинге (если флаг -fuzz задан регулярным выражением, соответствующим определенному фаззинг-тесту) целевая функция вызывается с аргументами, полученными путем многократного случайного изменения начальных входных данных. На поддерживаемых платформах 'go test' компилирует исполняемый файл тестов с инструментированием покрытия для фаззинга. Движок фаззинга использует это инструментирование, чтобы находить и кешировать входные данные, расширяющие покрытие, тем самым повышая вероятность обнаружения ошибок. Если целевая функция завершается с ошибкой для определенных входных данных, движок фаззинга записывает эти данные в файл каталога testdata/fuzz/<Name> в каталоге пакета. Позже этот файл используется как начальные входные данные. Если файл не удается записать в это место (например, потому что каталог доступен только для чтения), движок фаззинга сохраняет его в каталоге кеша фаззинга внутри кеша сборки.
Если фаззинг отключен, целевая функция вызывается с начальными входными данными, зарегистрированными с помощью F.Add, и начальными данными из testdata/fuzz/<Name>. В этом режиме фаззинг-тест работает почти как обычный тест, но вместо T.Run запускает под-тесты с помощью F.Fuzz.
Документацию о фаззинге см. по адресу https://go.dev/doc/fuzz.
Пропуск тестов
Тесты или бенчмарки можно пропустить во время выполнения, вызвав T.Skip или B.Skip:
func TestTimeConsuming(t *testing.T) {
if testing.Short() {
t.Skip("skipping test in short mode.")
}
...
}
Метод T.Skip можно использовать в целевой функции фаззинга, если входные данные недопустимы и не должны считаться ошибочными. Например:
func FuzzJSONMarshaling(f *testing.F) {
f.Fuzz(func(t *testing.T, b []byte) {
var v interface{}
if err := json.Unmarshal(b, &v); err != nil {
t.Skip()
}
if _, err := json.Marshal(v); err != nil {
t.Errorf("Marshal: %v", err)
}
})
}
Подтесты и подбенчмарки
Методы T.Run и B.Run позволяют определять подтесты и подбенчмарки без необходимости создавать для каждого отдельную функцию. Это позволяет, например, использовать бенчмарки на основе таблиц и создавать иерархические тесты. Кроме того, это дает возможность совместно использовать код подготовки и очистки:
func TestFoo(t *testing.T) {
// <setup code>
t.Run("A=1", func(t *testing.T) { ... })
t.Run("A=2", func(t *testing.T) { ... })
t.Run("B=1", func(t *testing.T) { ... })
// <tear-down code>
}
У каждого подтеста и подбенчмарка есть уникальное имя: сочетание имени теста верхнего уровня и последовательности имен, переданных в Run и разделенных косыми чертами, с необязательным завершающим порядковым номером для устранения неоднозначности.
Аргумент флагов командной строки -run, -bench и -fuzz — это незаякоренное регулярное выражение, соответствующее имени теста. Для тестов с несколькими элементами, разделенными косыми чертами, например подтестов, аргумент также разделяется косыми чертами, а выражения последовательно соответствуют каждому элементу имени. Поскольку выражение не заякорено, пустое выражение соответствует любой строке. Например, если под «совпадением» понимать «содержит в имени»:
go test -run '' # Run all tests. go test -run Foo # Run top-level tests matching "Foo", such as "TestFooBar". go test -run Foo/A= # For top-level tests matching "Foo", run subtests matching "A=". go test -run /A=1 # For all top-level tests, run subtests matching "A=1". go test -fuzz FuzzFoo # Fuzz the target matching "FuzzFoo"
Аргумент -run также можно использовать для запуска конкретного значения из начального корпуса с целью отладки. Например:
go test -run=FuzzFoo/9ddb952d9814
Флаги -fuzz и -run можно задать одновременно, чтобы запустить фаззинг целевой функции, пропустив выполнение всех остальных тестов.
Подтесты также можно использовать для управления параллелизмом. Родительский тест завершается только после завершения всех своих подтестов. В этом примере все тесты выполняются параллельно друг с другом и только друг с другом, независимо от других тестов верхнего уровня, которые могут быть определены:
func TestGroupedParallel(t *testing.T) {
for _, tc := range tests {
t.Run(tc.Name, func(t *testing.T) {
t.Parallel()
...
})
}
}
Run не возвращает управление, пока не завершатся параллельные подтесты, что позволяет выполнить очистку после группы параллельных тестов:
func TestTeardownParallel(t *testing.T) {
// This Run will not return until the parallel tests finish.
t.Run("group", func(t *testing.T) {
t.Run("Test1", parallelTest1)
t.Run("Test2", parallelTest2)
t.Run("Test3", parallelTest3)
})
// <tear-down code>
}
Main
Иногда тестовой программе или программе бенчмарков необходимо выполнить дополнительную подготовку или очистку до или после запуска. Иногда также необходимо контролировать, какой код выполняется в главном потоке. Для поддержки этих и других случаев, если тестовый файл содержит функцию:
func TestMain(m *testing.M)
то сгенерированный тест вызовет TestMain(m), а не запустит тесты или бенчмарки напрямую. TestMain выполняется в главной горутине и может выполнять необходимую подготовку и очистку вокруг вызова m.Run. m.Run возвращает код завершения, который можно передать в os.Exit. Если TestMain возвращает управление, тестовая обертка сама передаст результат m.Run в os.Exit.
При вызове TestMain функция flag.Parse еще не выполнялась. Если TestMain использует флаги командной строки, включая флаги пакета testing, ей следует явно вызвать flag.Parse. К моменту запуска функций тестов или бенчмарков флаги командной строки всегда уже разобраны.
Простая реализация TestMain:
func TestMain(m *testing.M) {
// call flag.Parse() here if TestMain uses flags
m.Run()
}
TestMain — низкоуровневый примитив, который не должен требоваться для обычных задач тестирования: достаточно стандартных тестовых функций.
Индекс
Файлы пакета
allocs.go benchmark.go cover.go example.go fuzz.go match.go newcover.go run_example.go testing.go testing_other.go
func AllocsPerRun 1.1
func AllocsPerRun(runs int, f func()) (avg float64)
AllocsPerRun возвращает среднее количество выделений памяти при вызовах f. Хотя возвращаемое значение имеет тип float64, оно всегда будет целым числом.
Для вычисления количества выделений функция сначала выполнится один раз для прогрева. Затем будет измерено и возвращено среднее количество выделений за указанное число запусков.
Во время измерения AllocsPerRun устанавливает значение runtime.GOMAXPROCS в 1 и восстанавливает его перед возвратом.
func CoverMode 1.8
func CoverMode() string
CoverMode сообщает, какой режим покрытия тестов установлен. Возможные значения: "set", "count" или "atomic". Если покрытие тестов не включено, возвращаемое значение будет пустым.
func Coverage 1.4
func Coverage() float64
Coverage сообщает текущее покрытие кода в виде доли в диапазоне [0, 1]. Если покрытие не включено, Coverage возвращает 0.
При запуске большого набора последовательных тестовых случаев проверка Coverage после каждого из них может помочь определить, какие случаи задействуют новые пути выполнения кода. Эта проверка не заменяет отчеты, создаваемые командами 'go test -cover' и 'go tool cover'.
func Init 1.13
func Init()
Init регистрирует флаги тестирования. Команда "go test" регистрирует эти флаги автоматически перед запуском тестовых функций, поэтому Init нужен только при вызове таких функций, как Benchmark, без использования "go test".
Init небезопасно вызывать одновременно из нескольких горутин. Если функция уже была вызвана, повторный вызов не повлияет на результат.
func Main
func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample)
Main — внутренняя функция, являющаяся частью реализации команды "go test". Она экспортирована, поскольку используется из других пакетов и появилась до пакетов "internal". Команда "go test" больше не использует эту функцию, однако она сохранена, насколько это возможно, для других систем, имитирующих работу "go test" с помощью Main. При этом иногда Main нельзя обновить при добавлении новых возможностей в пакет testing. Системы, имитирующие "go test", следует обновить для использования MainStart.
func RegisterCover 1.2
func RegisterCover(c Cover)
RegisterCover регистрирует накопители данных о покрытии для тестов. ПРИМЕЧАНИЕ: эта функция относится к инфраструктуре тестирования и может измениться. (Пока) на нее не распространяются рекомендации по совместимости Go 1.
func RunBenchmarks
func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark)
RunBenchmarks — внутренняя функция, экспортированная из-за использования в других пакетах; она является частью реализации команды "go test".
func RunExamples
func RunExamples(matchString func(pat, str string) (bool, error), examples []InternalExample) (ok bool)
RunExamples — внутренняя функция, экспортированная из-за использования в других пакетах; она является частью реализации команды "go test".
func RunTests
func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool)
RunTests — внутренняя функция, экспортированная из-за использования в других пакетах; она является частью реализации команды "go test".
func Short
func Short() bool
Short сообщает, установлен ли флаг -test.short.
func Testing 1.21
func Testing() bool
Testing сообщает, выполняется ли текущий код в режиме тестирования. Функция возвращает true в программах, созданных командой "go test", и false в программах, созданных командой "go build".
func Verbose 1.1
func Verbose() bool
Verbose сообщает, установлен ли флаг -test.v.
type B
B — это тип, передаваемый функциям Benchmark для управления временем бенчмарка и количеством итераций.
Бенчмарк завершается, когда его функция Benchmark возвращает управление или вызывает один из методов B.FailNow, B.Fatal, B.Fatalf, B.SkipNow, B.Skip или B.Skipf. Эти методы можно вызывать только из горутины, выполняющей функцию Benchmark. Другие методы вывода сообщений, например варианты B.Log и B.Error, можно одновременно вызывать из нескольких горутин.
Как и в тестах, журналы бенчмарков накапливаются во время выполнения и выводятся в стандартный вывод по его завершении. В отличие от тестов, журналы бенчмарков печатаются всегда, чтобы не скрывать вывод, наличие которого может влиять на результаты бенчмарка.
type B struct {
N int
// contains filtered or unexported fields
}
func (*B) ArtifactDir 1.26
func (c *B) ArtifactDir() string
ArtifactDir возвращает каталог, в котором тест должен сохранять выходные файлы. Если указан флаг -artifacts, этот каталог находится внутри каталога вывода. В противном случае ArtifactDir возвращает временный каталог, удаляемый после завершения теста.
У каждого теста или подтеста в каждом тестовом пакете есть уникальный каталог артефактов. Повторные вызовы ArtifactDir в рамках одного теста или подтеста возвращают один и тот же каталог. Вывод подтестов не находится внутри каталога вывода родительского теста.
func (*B) Attr 1.25
func (c *B) Attr(key, value string)
Attr выводит атрибут теста, связанный с этим тестом.
Ключ не должен содержать пробельных символов. Значение не должно содержать символов новой строки или возврата каретки.
Значение различных ключей атрибутов определяется системами непрерывной интеграции и тестовыми средами.
Атрибуты теста выводятся в журнал теста немедленно, но их следует считать неупорядоченными.
func (*B) Chdir 1.24
func (c *B) Chdir(dir string)
Chdir вызывает os.Chdir и использует Cleanup, чтобы восстановить исходный рабочий каталог после завершения теста. В Unix эта функция также устанавливает переменную окружения PWD на время выполнения теста.
Поскольку Chdir влияет на весь процесс, ее нельзя использовать в параллельных тестах или тестах с параллельными предками.
func (*B) Cleanup 1.14
func (c *B) Cleanup(f func())
Cleanup регистрирует функцию, вызываемую после завершения теста (или подтеста) и всех его подтестов. Функции очистки вызываются в обратном порядке регистрации.
func (*B) Context 1.24
func (c *B) Context() context.Context
Context возвращает контекст, который отменяется непосредственно перед вызовом функций, зарегистрированных с помощью Cleanup.
Функции очистки могут дождаться завершения работы ресурсов, которые останавливаются при вызове context.Context.Done, до завершения теста или бенчмарка.
func (*B) Elapsed 1.20
func (b *B) Elapsed() time.Duration
Elapsed возвращает измеренное время выполнения бенчмарка. Длительность, сообщаемая Elapsed, совпадает с длительностью, измеренной с помощью B.StartTimer, B.StopTimer и B.ResetTimer.
func (*B) Error
func (c *B) Error(args ...any)
Error эквивалентен вызову Log, за которым следует Fail.
func (*B) Errorf
func (c *B) Errorf(format string, args ...any)
Errorf эквивалентен вызову Logf, за которым следует Fail.
func (*B) Fail
func (c *B) Fail()
Fail помечает функцию как завершившуюся с ошибкой, но продолжает ее выполнение.
func (*B) FailNow
func (c *B) FailNow()
FailNow помечает функцию как завершившуюся с ошибкой и останавливает ее выполнение, вызывая runtime.Goexit (после чего выполняются все отложенные вызовы в текущей горутине). Выполнение продолжится со следующего теста или бенчмарка. FailNow необходимо вызывать из горутины, выполняющей функцию теста или бенчмарка, а не из других горутин, созданных во время теста. Вызов FailNow не останавливает эти другие горутины.
func (*B) Failed
func (c *B) Failed() bool
Failed сообщает, завершилась ли функция с ошибкой.
func (*B) Fatal
func (c *B) Fatal(args ...any)
Fatal эквивалентен вызову Log, за которым следует FailNow.
func (*B) Fatalf
func (c *B) Fatalf(format string, args ...any)
Fatalf эквивалентен вызову Logf, за которым следует FailNow.
func (*B) Helper 1.9
func (c *B) Helper()
Helper помечает вызывающую функцию как вспомогательную функцию теста. При выводе сведений о файле и строке эта функция будет пропущена. Helper можно одновременно вызывать из нескольких горутин.
func (*B) Log
func (c *B) Log(args ...any)
Log форматирует аргументы с помощью форматирования по умолчанию, аналогично fmt.Println, и записывает текст в журнал ошибок. Для тестов текст выводится только в случае ошибки теста или если установлен флаг -test.v. Для бенчмарков текст выводится всегда, чтобы производительность не зависела от значения флага -test.v. Вызов Log после завершения теста или бенчмарка считается ошибкой.
func (*B) Logf
func (c *B) Logf(format string, args ...any)
Logf форматирует аргументы в соответствии с форматом, аналогично fmt.Printf, и записывает текст в журнал ошибок. Если завершающий символ новой строки не указан, он добавляется. Для тестов текст выводится только в случае ошибки теста или если установлен флаг -test.v. Для бенчмарков текст выводится всегда, чтобы производительность не зависела от значения флага -test.v. Вызов Logf после завершения теста или бенчмарка считается ошибкой.
func (*B) Loop 1.24
func (b *B) Loop() bool
Loop возвращает true, пока бенчмарк должен продолжать выполняться.
Типичная структура бенчмарка:
func Benchmark(b *testing.B) {
... setup ...
for b.Loop() {
... code to measure ...
}
... cleanup ...
}
При первом вызове в бенчмарке Loop сбрасывает таймер бенчмарка, поэтому подготовка, выполненная до начала цикла бенчмарка, не учитывается при измерении. Аналогично, когда функция возвращает false, она останавливает таймер, поэтому код очистки не измеряется.
Внутри тела цикла "for b.Loop() { ... }" аргументы и результаты вызовов функций, а также присвоенные переменным значения внутри цикла остаются активными, что не позволяет компилятору полностью оптимизировать тело цикла. В настоящее время это реализовано как преобразование компилятора, оборачивающее такие переменные вызовом встроенной функции runtime.KeepAlive. Это относится только к инструкциям, синтаксически расположенным между фигурными скобками цикла; условие цикла должно быть записано точно как "b.Loop()".
После того как Loop возвращает false, b.N содержит общее число выполненных итераций, поэтому бенчмарк может использовать b.N для вычисления других средних показателей.
До появления Loop предполагалось, что бенчмарки содержат явный цикл от 0 до b.N. Бенчмарки должны либо использовать Loop, либо содержать цикл до b.N, но не то и другое одновременно. Loop обеспечивает более автоматическое управление таймером бенчмарка и запускает каждую функцию бенчмарка только один раз за измерение, тогда как бенчмарки на основе b.N должны запускать функцию бенчмарка (а также связанный с ней код подготовки и очистки) несколько раз.
Пример
Код:
package testing_test
import (
"math/rand/v2"
"testing"
)
// ExBenchmark shows how to use b.Loop in a benchmark.
//
// (If this were a real benchmark, not an example, this would be named
// BenchmarkSomething.)
func ExBenchmark(b *testing.B) {
// Generate a large random slice to use as an input.
// Since this is done before the first call to b.Loop(),
// it doesn't count toward the benchmark time.
input := make([]int, 128<<10)
for i := range input {
input[i] = rand.Int()
}
// Perform the benchmark.
for b.Loop() {
// Normally, the compiler would be allowed to optimize away the call
// to sum because it has no side effects and the result isn't used.
// However, inside a b.Loop loop, the compiler ensures function calls
// aren't optimized away.
sum(input)
}
// Outside the loop, the timer is stopped, so we could perform
// cleanup if necessary without affecting the result.
}
func sum(data []int) int {
total := 0
for _, value := range data {
total += value
}
return total
}
func ExampleB_Loop() {
testing.Benchmark(ExBenchmark)
}
func (*B) Name 1.8
func (c *B) Name() string
Name возвращает имя выполняемого теста (или подтеста) либо бенчмарка.
Имя включает имя теста, а также имена всех вложенных подтестов. Если два соседних подтеста имеют одинаковое имя, Name добавляет суффикс, чтобы возвращаемое имя было уникальным.
func (*B) Output 1.25
func (c *B) Output() io.Writer
Output возвращает Writer, который записывает данные в тот же поток вывода теста, что и TB.Log. Вывод форматируется с отступом, как строки TB.Log, но Output не добавляет сведения об исходном файле и номере строки или символы новой строки. Вывод внутри буферизуется построчно; вызов TB.Log или завершение теста неявно сбрасывает буфер, добавляя символ новой строки. После завершения функции теста и всех ее родительских функций нельзя вызывать ни Output, ни метод Write.
func (*B) ReportAllocs 1.1
func (b *B) ReportAllocs()
ReportAllocs включает сбор статистики о выделениях памяти для этого бенчмарка. Это эквивалентно установке флага -test.benchmem, но влияет только на функцию бенчмарка, вызвавшую ReportAllocs.
func (*B) ReportMetric 1.13
func (b *B) ReportMetric(n float64, unit string)
ReportMetric добавляет «n unit» к результатам бенчмарка. Если метрика рассчитывается за итерацию, вызывающая функция должна разделить значение на b.N; по соглашению единицы измерения должны оканчиваться на «/op». ReportMetric заменяет любое ранее заданное значение для той же единицы измерения. ReportMetric вызывает панику, если unit — пустая строка или содержит пробельные символы. Если unit обозначает единицу измерения, обычно выводимую самой системой бенчмарков (например, «allocs/op»), ReportMetric заменит эту метрику. Установка значения «ns/op» в 0 подавляет эту встроенную метрику.
Пример
Код:
// This reports a custom benchmark metric relevant to a
// specific algorithm (in this case, sorting).
testing.Benchmark(func(b *testing.B) {
var compares int64
for b.Loop() {
s := []int{5, 4, 3, 2, 1}
slices.SortFunc(s, func(a, b int) int {
compares++
return cmp.Compare(a, b)
})
}
// This metric is per-operation, so divide by b.N and
// report it as a "/op" unit.
b.ReportMetric(float64(compares)/float64(b.N), "compares/op")
// This metric is per-time, so divide by b.Elapsed and
// report it as a "/ns" unit.
b.ReportMetric(float64(compares)/float64(b.Elapsed().Nanoseconds()), "compares/ns")
})
Пример (параллельный)
Код:
// This reports a custom benchmark metric relevant to a
// specific algorithm (in this case, sorting) in parallel.
testing.Benchmark(func(b *testing.B) {
var compares atomic.Int64
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
s := []int{5, 4, 3, 2, 1}
slices.SortFunc(s, func(a, b int) int {
// Because RunParallel runs the function many
// times in parallel, we must increment the
// counter atomically to avoid racing writes.
compares.Add(1)
return cmp.Compare(a, b)
})
}
})
// NOTE: Report each metric once, after all of the parallel
// calls have completed.
// This metric is per-operation, so divide by b.N and
// report it as a "/op" unit.
b.ReportMetric(float64(compares.Load())/float64(b.N), "compares/op")
// This metric is per-time, so divide by b.Elapsed and
// report it as a "/ns" unit.
b.ReportMetric(float64(compares.Load())/float64(b.Elapsed().Nanoseconds()), "compares/ns")
})
func (*B) ResetTimer
func (b *B) ResetTimer()
ResetTimer обнуляет прошедшее время бенчмарка и счетчики выделения памяти, а также удаляет метрики, заданные пользователем. Не влияет на состояние таймера — запущен он или остановлен.
func (*B) Run 1.7
func (b *B) Run(name string, f func(b *B)) bool
Run запускает бенчмарк f как подбенчмарк с указанным именем. Метод сообщает, произошли ли ошибки.
Подбенчмарк ничем не отличается от обычного бенчмарка. Бенчмарк, вызывающий Run хотя бы один раз, сам измеряться не будет и будет вызван один раз с N=1.
func (*B) RunParallel 1.3
func (b *B) RunParallel(body func(*PB))
RunParallel запускает бенчмарк параллельно. Он создает несколько горутин и распределяет между ними b.N итераций. По умолчанию количество горутин равно GOMAXPROCS. Чтобы увеличить параллелизм в бенчмарках, не ограниченных производительностью CPU, вызовите B.SetParallelism перед RunParallel. RunParallel обычно используется вместе с флагом go test -cpu.
Функция тела бенчмарка будет выполняться в каждой горутине. Она должна подготовить локальное для горутины состояние, а затем выполнять итерации, пока pb.Next не вернет false. Не следует использовать функции B.StartTimer, B.StopTimer или B.ResetTimer, поскольку они влияют на глобальное состояние. Также не следует вызывать B.Run.
RunParallel сообщает значения ns/op как реальное время выполнения бенчмарка в целом, а не как сумму реального времени или времени CPU всех параллельных горутин.
Пример
Код:
// Parallel benchmark for text/template.Template.Execute on a single object.
testing.Benchmark(func(b *testing.B) {
templ := template.Must(template.New("test").Parse("Hello, {{.}}!"))
// RunParallel will create GOMAXPROCS goroutines
// and distribute work among them.
b.RunParallel(func(pb *testing.PB) {
// Each goroutine has its own bytes.Buffer.
var buf bytes.Buffer
for pb.Next() {
// The loop body is executed b.N times total across all goroutines.
buf.Reset()
templ.Execute(&buf, "World")
}
})
})
func (*B) SetBytes
func (b *B) SetBytes(n int64)
SetBytes задает количество байтов, обрабатываемых за одну операцию. Если вызвать этот метод, бенчмарк будет выводить значения ns/op и MB/s.
func (*B) SetParallelism 1.3
func (b *B) SetParallelism(p int)
SetParallelism задает количество горутин, используемых методом B.RunParallel: p*GOMAXPROCS. Для бенчмарков, ограниченных производительностью CPU, обычно нет необходимости вызывать SetParallelism. Если p меньше 1, вызов не оказывает эффекта.
func (*B) Setenv 1.17
func (c *B) Setenv(key, value string)
Setenv вызывает os.Setenv и использует Cleanup, чтобы после теста восстановить исходное значение переменной окружения.
Поскольку Setenv влияет на весь процесс, его нельзя использовать в параллельных тестах и тестах с параллельными родительскими тестами.
func (*B) Skip 1.1
func (c *B) Skip(args ...any)
Skip эквивалентен вызову Log, за которым следует SkipNow.
func (*B) SkipNow 1.1
func (c *B) SkipNow()
SkipNow помечает тест как пропущенный и останавливает его выполнение, вызывая runtime.Goexit. Если тест завершился с ошибкой (см. Error, Errorf, Fail), а затем был пропущен, он все равно считается завершившимся с ошибкой. Выполнение продолжится со следующего теста или бенчмарка. См. также FailNow. SkipNow необходимо вызывать из горутины, выполняющей тест, а не из других горутин, созданных во время теста. Вызов SkipNow не останавливает эти другие горутины.
func (*B) Skipf 1.1
func (c *B) Skipf(format string, args ...any)
Skipf эквивалентен вызову Logf, за которым следует SkipNow.
func (*B) Skipped 1.1
func (c *B) Skipped() bool
Skipped сообщает, был ли тест пропущен.
func (*B) StartTimer
func (b *B) StartTimer()
StartTimer запускает отсчет времени теста. Эта функция автоматически вызывается перед запуском бенчмарка, но ее также можно использовать, чтобы возобновить отсчет после вызова B.StopTimer.
func (*B) StopTimer
func (b *B) StopTimer()
StopTimer останавливает отсчет времени теста. Его можно использовать, чтобы приостановить таймер во время выполнения действий, которые не нужно измерять.
func (*B) TempDir 1.15
func (c *B) TempDir() string
TempDir возвращает временный каталог для использования тестом. Каталог автоматически удаляется после завершения теста и всех его подтестов. Каждый последующий вызов TempDir возвращает уникальный каталог; если создать каталог не удалось, TempDir завершает тест вызовом Fatal. Если задана переменная окружения GOTMPDIR, временный каталог будет создан где-либо внутри нее.
type BenchmarkResult
BenchmarkResult содержит результаты запуска бенчмарка.
type BenchmarkResult struct {
N int // The number of iterations.
T time.Duration // The total time taken.
Bytes int64 // Bytes processed in one iteration.
MemAllocs uint64 // The total number of memory allocations; added in Go 1.1
MemBytes uint64 // The total number of bytes allocated; added in Go 1.1
// Extra records additional metrics reported by ReportMetric.
Extra map[string]float64 // Go 1.13
}
func Benchmark
func Benchmark(f func(b *B)) BenchmarkResult
Benchmark выполняет одну функцию бенчмарка. Он полезен для создания пользовательских бенчмарков, не использующих команду «go test».
Если f зависит от флагов пакета testing, перед вызовом Benchmark и flag.Parse необходимо вызвать Init, чтобы зарегистрировать эти флаги.
Если f вызывает Run, результат будет оценкой выполнения всех ее подбенчмарков, не вызывающих Run, последовательно в рамках одного бенчмарка.
func (BenchmarkResult) AllocedBytesPerOp 1.1
func (r BenchmarkResult) AllocedBytesPerOp() int64
AllocedBytesPerOp возвращает метрику «B/op», вычисляемую как r.MemBytes / r.N.
func (BenchmarkResult) AllocsPerOp 1.1
func (r BenchmarkResult) AllocsPerOp() int64
AllocsPerOp возвращает метрику «allocs/op», вычисляемую как r.MemAllocs / r.N.
func (BenchmarkResult) MemString 1.1
func (r BenchmarkResult) MemString() string
MemString возвращает значения r.AllocedBytesPerOp и r.AllocsPerOp в том же формате, что и «go test».
func (BenchmarkResult) NsPerOp
func (r BenchmarkResult) NsPerOp() int64
NsPerOp возвращает метрику «ns/op».
func (BenchmarkResult) String
func (r BenchmarkResult) String() string
String возвращает сводку результатов бенчмарка. Формат соответствует строке результата бенчмарка из https://golang.org/design/14313-benchmark-format, без имени бенчмарка. Дополнительные метрики заменяют встроенные метрики с теми же именами. String не включает allocs/op или B/op, поскольку они выводятся методом BenchmarkResult.MemString.
type Cover 1.2
Cover содержит сведения о проверке покрытия кода тестами. ПРИМЕЧАНИЕ: эта структура является внутренней частью инфраструктуры тестирования и может измениться. На нее пока не распространяются рекомендации по совместимости Go 1.
type Cover struct {
Mode string
Counters map[string][]uint32
Blocks map[string][]CoverBlock
CoveredPackages string
}
type CoverBlock 1.2
CoverBlock содержит данные о покрытии для одного базового блока. Нумерация полей начинается с 1, как в редакторе: например, первая строка файла имеет номер 1. Столбцы измеряются в байтах. ПРИМЕЧАНИЕ: эта структура является внутренней частью инфраструктуры тестирования и может измениться. На нее пока не распространяются рекомендации по совместимости Go 1.
type CoverBlock struct {
Line0 uint32 // Line number for block start.
Col0 uint16 // Column number for block start.
Line1 uint32 // Line number for block end.
Col1 uint16 // Column number for block end.
Stmts uint16 // Number of statements included in this block.
}
type F 1.18
F — это тип, передаваемый фаззинг-тестам.
Фаззинг-тесты проверяют сгенерированные входные данные с помощью заданной функции-цели фаззинга, которая может обнаруживать и сообщать о потенциальных ошибках в проверяемом коде.
По умолчанию фаззинг-тест запускает исходный корпус, содержащий элементы, добавленные с помощью F.Add, и элементы из каталога testdata/fuzz/<FuzzTestName>. После необходимой подготовки и вызовов F.Add фаззинг-тест должен вызвать F.Fuzz, чтобы задать функцию-цель фаззинга. Пример приведен в документации пакета testing; подробности см. в документации методов F.Fuzz и F.Add.
Методы *F можно вызывать только до F.Fuzz. После начала выполнения функции-цели фаззинга можно использовать только методы *T. В функции F.Fuzz разрешено вызывать только методы *F F.Failed и F.Name.
type F struct {
// contains filtered or unexported fields
}
func (*F) Add 1.18
func (f *F) Add(args ...any)
Add добавляет аргументы в исходный корпус фаззинг-теста. Если вызвать его после запуска функции-цели фаззинга или внутри нее, вызов ничего не сделает; аргументы должны соответствовать аргументам функции-цели фаззинга.
func (*F) ArtifactDir 1.26
func (c *F) ArtifactDir() string
ArtifactDir возвращает каталог, в котором тест должен сохранять выходные файлы. Если указан флаг -artifacts, этот каталог находится внутри каталога вывода. В противном случае ArtifactDir возвращает временный каталог, который удаляется после завершения теста.
Для каждого теста или подтеста в каждом пакете тестов создается уникальный каталог артефактов. Повторные вызовы ArtifactDir в одном и том же тесте или подтесте возвращают один и тот же каталог. Выходные данные подтестов не находятся в каталоге вывода родительского теста.
func (*F) Attr 1.25
func (c *F) Attr(key, value string)
Attr выводит атрибут теста, связанный с этим тестом.
Ключ не должен содержать пробельных символов. Значение не должно содержать символов новой строки или возврата каретки.
Интерпретация различных ключей атрибутов определяется системами непрерывной интеграции и средствами тестирования.
Атрибуты теста сразу выводятся в журнал теста, но предполагается, что их порядок не имеет значения.
func (*F) Chdir 1.24
func (c *F) Chdir(dir string)
Chdir вызывает os.Chdir и использует Cleanup, чтобы после теста восстановить исходный текущий рабочий каталог. В Unix он также устанавливает переменную окружения PWD на время выполнения теста.
Поскольку Chdir влияет на весь процесс, его нельзя использовать в параллельных тестах и тестах с параллельными родительскими тестами.
func (*F) Cleanup 1.18
func (c *F) Cleanup(f func())
Cleanup регистрирует функцию, которая будет вызвана после завершения теста (или подтеста) и всех его подтестов. Функции очистки вызываются в порядке, обратном порядку их регистрации.
func (*F) Context 1.24
func (c *F) Context() context.Context
Context возвращает контекст, который отменяется непосредственно перед вызовом зарегистрированных в Cleanup функций.
Функции очистки могут дождаться завершения работы ресурсов, останавливающихся при вызове context.Context.Done, прежде чем завершится тест или бенчмарк.
func (*F) Error 1.18
func (c *F) Error(args ...any)
Error эквивалентен вызову Log, за которым следует Fail.
func (*F) Errorf 1.18
func (c *F) Errorf(format string, args ...any)
Errorf эквивалентен вызову Logf, за которым следует Fail.
func (*F) Fail 1.18
func (f *F) Fail()
Fail помечает функцию как завершившуюся с ошибкой, но продолжает выполнение.
func (*F) FailNow 1.18
func (c *F) FailNow()
FailNow помечает функцию как завершившуюся с ошибкой и останавливает ее выполнение, вызывая runtime.Goexit (после чего выполняются все отложенные вызовы в текущей горутине). Выполнение продолжится со следующего теста или бенчмарка. FailNow необходимо вызывать из горутины, выполняющей функцию теста или бенчмарка, а не из других горутин, созданных во время теста. Вызов FailNow не останавливает эти другие горутины.
func (*F) Failed 1.18
func (c *F) Failed() bool
Failed сообщает, завершилась ли функция с ошибкой.
func (*F) Fatal 1.18
func (c *F) Fatal(args ...any)
Fatal эквивалентен вызову Log, за которым следует FailNow.
func (*F) Fatalf 1.18
func (c *F) Fatalf(format string, args ...any)
Fatalf эквивалентен вызову Logf, за которым следует FailNow.
func (*F) Fuzz 1.18
func (f *F) Fuzz(ff any)
Fuzz запускает функцию фаззинга ff для фаззинг-тестирования. Если ff завершается с ошибкой для некоторого набора аргументов, эти аргументы добавляются в исходный корпус.
ff должна быть функцией без возвращаемого значения, первым аргументом которой является *T, а остальные аргументы имеют типы, подлежащие фаззингу. Например:
f.Fuzz(func(t *testing.T, b []byte, i int) { ... })
Разрешены следующие типы: []byte, string, bool, byte, rune, float32, float64, int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64. В будущем могут поддерживаться и другие типы.
ff не должна вызывать методы *F, например F.Log, F.Error, F.Skip. Вместо них используйте соответствующий метод *T. В функции F.Fuzz разрешено вызывать только методы *F F.Failed и F.Name.
Эта функция должна быть быстрой и детерминированной, а ее поведение не должно зависеть от общего состояния. Не следует сохранять изменяемые входные аргументы или указатели на них между вызовами функции фаззинга, поскольку память, на которую они указывают, может быть изменена при последующем вызове. ff не должна изменять базовые данные аргументов, предоставленных механизмом фаззинга.
При фаззинге F.Fuzz не возвращает управление, пока не будет обнаружена проблема, не истечет время (задаваемое флагом -fuzztime) или процесс тестирования не будет прерван сигналом. F.Fuzz следует вызывать ровно один раз, если до этого не был вызван F.Skip или F.Fail.
func (*F) Helper 1.18
func (f *F) Helper()
Helper помечает вызывающую функцию как вспомогательную функцию теста. При выводе сведений о файле и номере строки эта функция будет пропущена. Helper можно одновременно вызывать из нескольких горутин.
func (*F) Log 1.18
func (c *F) Log(args ...any)
Log форматирует аргументы стандартным способом, аналогично fmt.Println, и записывает текст в журнал ошибок. Для тестов текст выводится только в случае ошибки теста или при установленном флаге -test.v. Для бенчмарков текст выводится всегда, чтобы производительность не зависела от значения флага -test.v. Вызов Log после завершения теста или бенчмарка считается ошибкой.
func (*F) Logf 1.18
func (c *F) Logf(format string, args ...any)
Logf форматирует аргументы в соответствии с форматом, аналогично fmt.Printf, и записывает текст в журнал ошибок. Если в конце нет символа новой строки, он добавляется. Для тестов текст выводится только в случае ошибки теста или при установленном флаге -test.v. Для бенчмарков текст выводится всегда, чтобы производительность не зависела от значения флага -test.v. Вызов Logf после завершения теста или бенчмарка считается ошибкой.
func (*F) Name 1.18
func (c *F) Name() string
Name возвращает имя выполняемого теста (или подтеста) либо бенчмарка.
Имя включает имя теста, а также имена всех вложенных подтестов. Если два соседних подтеста имеют одинаковое имя, Name добавляет суффикс, чтобы возвращаемое имя было уникальным.
func (*F) Output 1.25
func (c *F) Output() io.Writer
Output возвращает Writer, который записывает данные в тот же поток вывода теста, что и TB.Log. Вывод форматируется с отступом, как строки TB.Log, но Output не добавляет сведения об исходном файле и номере строки или символы новой строки. Вывод внутри буферизуется построчно; вызов TB.Log или завершение теста неявно сбрасывает буфер, добавляя символ новой строки. После завершения функции теста и всех ее родительских функций нельзя вызывать ни Output, ни метод Write.
func (*F) Setenv 1.18
func (c *F) Setenv(key, value string)
Setenv вызывает os.Setenv и использует Cleanup, чтобы после теста восстановить исходное значение переменной окружения.
Поскольку Setenv влияет на весь процесс, его нельзя использовать в параллельных тестах и тестах с параллельными родительскими тестами.
func (*F) Skip 1.18
func (c *F) Skip(args ...any)
Skip эквивалентен вызову Log, за которым следует SkipNow.
func (*F) SkipNow 1.18
func (c *F) SkipNow()
SkipNow помечает тест как пропущенный и останавливает его выполнение, вызывая runtime.Goexit. Если тест завершился с ошибкой (см. Error, Errorf, Fail), а затем был пропущен, он все равно считается завершившимся с ошибкой. Выполнение продолжится со следующего теста или бенчмарка. См. также FailNow. SkipNow необходимо вызывать из горутины, выполняющей тест, а не из других горутин, созданных во время теста. Вызов SkipNow не останавливает эти другие горутины.
func (*F) Skipf 1.18
func (c *F) Skipf(format string, args ...any)
Skipf эквивалентен вызову Logf, за которым следует SkipNow.
func (*F) Skipped 1.18
func (f *F) Skipped() bool
Skipped сообщает, был ли тест пропущен.
func (*F) TempDir 1.18
func (c *F) TempDir() string
TempDir возвращает временный каталог для использования тестом. Каталог автоматически удаляется после завершения теста и всех его подтестов. Каждый последующий вызов TempDir возвращает уникальный каталог; если создать каталог не удалось, TempDir завершает тест вызовом Fatal. Если задана переменная окружения GOTMPDIR, временный каталог будет создан где-либо внутри нее.
type InternalBenchmark
InternalBenchmark — внутренний тип, который экспортирован, поскольку используется в разных пакетах; он является частью реализации команды «go test».
type InternalBenchmark struct {
Name string
F func(b *B)
}
type InternalExample
type InternalExample struct {
Name string
F func()
Output string
Unordered bool // Go 1.7
}
type InternalFuzzTarget 1.18
InternalFuzzTarget — внутренний тип, который экспортирован, поскольку используется в разных пакетах; он является частью реализации команды «go test».
type InternalFuzzTarget struct {
Name string
Fn func(f *F)
}
type InternalTest
InternalTest — внутренний тип, который экспортирован, поскольку используется в разных пакетах; он является частью реализации команды «go test».
type InternalTest struct {
Name string
F func(*T)
}
type M 1.4
M — это тип, передаваемый функции TestMain для запуска собственно тестов.
type M struct {
// contains filtered or unexported fields
}
func MainStart 1.4
func MainStart(deps testDeps, tests []InternalTest, benchmarks []InternalBenchmark, fuzzTargets []InternalFuzzTarget, examples []InternalExample) *M
MainStart предназначен для использования тестами, сгенерированными командой «go test». Его не следует вызывать напрямую; на него не распространяется документ о совместимости Go 1. Сигнатура может меняться от выпуска к выпуску.
func (*M) Run 1.4
func (m *M) Run() (code int)
Run запускает тесты. Он возвращает код завершения, который следует передать в os.Exit. Код равен нулю, если все тесты пройдены, и ненулевому значению при любой ошибке. Чтобы получить машиночитаемые результаты тестов, разберите вывод команды «go test -json».
type PB 1.3
PB используется методом RunParallel для запуска параллельных бенчмарков.
type PB struct {
// contains filtered or unexported fields
}
func (*PB) Next 1.3
func (pb *PB) Next() bool
Next сообщает, остались ли еще итерации для выполнения.
type T
T — это тип, передаваемый функциям тестирования для управления состоянием теста и поддержки форматированных журналов тестирования.
Тест завершается, когда его функция Test возвращает управление или вызывает один из методов T.FailNow, T.Fatal, T.Fatalf, T.SkipNow, T.Skip или T.Skipf. Эти методы, а также метод T.Parallel, можно вызывать только из горутины, выполняющей функцию Test.
Другие методы отчетности, такие как варианты T.Log и T.Error, можно одновременно вызывать из нескольких горутин.
type T struct {
// contains filtered or unexported fields
}
func (*T) ArtifactDir 1.26
func (c *T) ArtifactDir() string
ArtifactDir возвращает каталог, в котором тест должен сохранять выходные файлы. Если указан флаг -artifacts, этот каталог находится внутри каталога вывода. В противном случае ArtifactDir возвращает временный каталог, который удаляется после завершения теста.
Для каждого теста или подтеста в каждом пакете тестов создается уникальный каталог артефактов. Повторные вызовы ArtifactDir в одном и том же тесте или подтесте возвращают один и тот же каталог. Выходные данные подтестов не находятся в каталоге вывода родительского теста.
func (*T) Attr 1.25
func (c *T) Attr(key, value string)
Attr выводит атрибут теста, связанный с этим тестом.
Ключ не должен содержать пробельных символов. Значение не должно содержать символов новой строки или возврата каретки.
Интерпретация различных ключей атрибутов определяется системами непрерывной интеграции и средствами тестирования.
Атрибуты теста сразу выводятся в журнал теста, но предполагается, что их порядок не имеет значения.
func (*T) Chdir 1.24
func (t *T) Chdir(dir string)
Chdir вызывает os.Chdir и использует Cleanup, чтобы после теста восстановить исходный текущий рабочий каталог. В Unix он также устанавливает переменную окружения PWD на время выполнения теста.
Поскольку Chdir влияет на весь процесс, его нельзя использовать в параллельных тестах и тестах с параллельными родительскими тестами.
func (*T) Cleanup 1.14
func (c *T) Cleanup(f func())
Cleanup регистрирует функцию, которая будет вызвана после завершения теста (или подтеста) и всех его подтестов. Функции очистки вызываются в порядке, обратном порядку их регистрации.
func (*T) Context 1.24
func (c *T) Context() context.Context
Context возвращает контекст, который отменяется непосредственно перед вызовом зарегистрированных в Cleanup функций.
Функции очистки могут дождаться завершения работы ресурсов, останавливающихся при вызове context.Context.Done, прежде чем завершится тест или бенчмарк.
func (*T) Deadline 1.15
func (t *T) Deadline() (deadline time.Time, ok bool)
Deadline сообщает время, к которому время ожидания, заданное флагом -timeout, истечет для бинарного файла тестов.
Результат ok равен false, если флаг -timeout указывает «без ограничения времени» (0).
func (*T) Error
func (c *T) Error(args ...any)
Error эквивалентен вызову Log, за которым следует Fail.
func (*T) Errorf
func (c *T) Errorf(format string, args ...any)
Errorf эквивалентен вызову Logf, за которым следует Fail.
func (*T) Fail
func (c *T) Fail()
Fail помечает функцию как завершившуюся с ошибкой, но продолжает выполнение.
func (*T) FailNow
func (c *T) FailNow()
FailNow помечает функцию как завершившуюся с ошибкой и останавливает ее выполнение, вызывая runtime.Goexit (после чего выполняются все отложенные вызовы в текущей горутине). Выполнение продолжится со следующего теста или бенчмарка. FailNow необходимо вызывать из горутины, выполняющей функцию теста или бенчмарка, а не из других горутин, созданных во время теста. Вызов FailNow не останавливает эти другие горутины.
func (*T) Failed
func (c *T) Failed() bool
Failed сообщает, завершилась ли функция с ошибкой.
func (*T) Fatal
func (c *T) Fatal(args ...any)
Fatal эквивалентен вызову Log, за которым следует FailNow.
func (*T) Fatalf
func (c *T) Fatalf(format string, args ...any)
Fatalf эквивалентен вызову Logf, за которым следует FailNow.
func (*T) Helper 1.9
func (c *T) Helper()
Helper помечает вызывающую функцию как вспомогательную функцию теста. При выводе сведений о файле и номере строки эта функция будет пропущена. Helper можно одновременно вызывать из нескольких горутин.
func (*T) Log
func (c *T) Log(args ...any)
Log форматирует аргументы стандартным способом, аналогично fmt.Println, и записывает текст в журнал ошибок. Для тестов текст выводится только в случае ошибки теста или при установленном флаге -test.v. Для бенчмарков текст выводится всегда, чтобы производительность не зависела от значения флага -test.v. Вызов Log после завершения теста или бенчмарка считается ошибкой.
func (*T) Logf
func (c *T) Logf(format string, args ...any)
Logf форматирует аргументы в соответствии с форматом, аналогично fmt.Printf, и записывает текст в журнал ошибок. Если в конце нет символа новой строки, он добавляется. Для тестов текст выводится только в случае ошибки теста или при установленном флаге -test.v. Для бенчмарков текст выводится всегда, чтобы производительность не зависела от значения флага -test.v. Вызов Logf после завершения теста или бенчмарка считается ошибкой.
func (*T) Name 1.8
func (c *T) Name() string
Name возвращает имя выполняемого теста (или подтеста) либо бенчмарка.
Имя включает имя теста, а также имена всех вложенных подтестов. Если два соседних подтеста имеют одинаковое имя, Name добавляет суффикс, чтобы возвращаемое имя было уникальным.
func (*T) Output 1.25
func (c *T) Output() io.Writer
Output возвращает Writer, который записывает данные в тот же поток вывода теста, что и TB.Log. Вывод форматируется с отступом, как строки TB.Log, но Output не добавляет сведения об исходном файле и номере строки или символы новой строки. Вывод внутри буферизуется построчно; вызов TB.Log или завершение теста неявно сбрасывает буфер, добавляя символ новой строки. После завершения функции теста и всех ее родительских функций нельзя вызывать ни Output, ни метод Write.
func (*T) Parallel
func (t *T) Parallel()
Parallel указывает, что этот тест следует выполнять параллельно (и только) с другими параллельными тестами, и приостанавливает его до завершения всех непараллельных тестов.
Если тест запускается несколько раз из-за использования флага -test.count или -test.cpu, несколько экземпляров одного теста никогда не выполняются параллельно друг с другом.
func (*T) Run 1.7
func (t *T) Run(name string, f func(t *T)) bool
Run запускает f как подтест t с именем name. Он выполняет f в отдельной горутине и блокируется до тех пор, пока f не вернет управление или не вызовет t.Parallel, чтобы стать параллельным тестом. Run сообщает, успешно ли завершилась f (или, по крайней мере, не завершилась с ошибкой до вызова t.Parallel).
Run можно одновременно вызывать из нескольких горутин, но все такие вызовы должны завершиться до возврата внешней функции теста для t.
func (*T) Setenv 1.17
func (t *T) Setenv(key, value string)
Setenv вызывает os.Setenv(key, value) и использует Cleanup для восстановления исходного значения переменной окружения после теста.
Поскольку Setenv влияет на весь процесс, его нельзя использовать в параллельных тестах или тестах с параллельными предками.
func (*T) Skip 1.1
func (c *T) Skip(args ...any)
Skip эквивалентен вызову Log, за которым следует SkipNow.
func (*T) SkipNow 1.1
func (c *T) SkipNow()
SkipNow отмечает тест как пропущенный и останавливает его выполнение, вызывая runtime.Goexit. Если тест завершается ошибкой (см. Error, Errorf, Fail), а затем пропускается, он всё равно считается завершившимся с ошибкой. Выполнение продолжится со следующего теста или бенчмарка. См. также FailNow. SkipNow необходимо вызывать из горутины, выполняющей тест, а не из других горутин, созданных во время теста. Вызов SkipNow не останавливает эти другие горутины.
func (*T) Skipf 1.1
func (c *T) Skipf(format string, args ...any)
Skipf эквивалентен вызову Logf, за которым следует SkipNow.
func (*T) Skipped 1.1
func (c *T) Skipped() bool
Skipped сообщает, был ли тест пропущен.
func (*T) TempDir 1.15
func (c *T) TempDir() string
TempDir возвращает временный каталог для использования в тесте. Каталог автоматически удаляется после завершения теста и всех его под-тестов. Каждый последующий вызов TempDir возвращает уникальный каталог; если создать каталог не удаётся, TempDir завершает тест, вызывая Fatal. Если задана переменная окружения GOTMPDIR, временный каталог будет создан где-либо внутри указанного ею каталога.
type TB 1.2
TB — это интерфейс, общий для T, B и F.
type TB interface {
ArtifactDir() string
Attr(key, value string)
Cleanup(func())
Error(args ...any)
Errorf(format string, args ...any)
Fail()
FailNow()
Failed() bool
Fatal(args ...any)
Fatalf(format string, args ...any)
Helper()
Log(args ...any)
Logf(format string, args ...any)
Name() string
Setenv(key, value string)
Chdir(dir string)
Skip(args ...any)
SkipNow()
Skipf(format string, args ...any)
Skipped() bool
TempDir() string
Context() context.Context
Output() io.Writer
// contains filtered or unexported methods
} Подкаталоги
| Имя | Описание |
|---|---|
| .. | |
| cryptotest | Пакет cryptotest предоставляет средства для тестирования детерминированных источников случайных данных. |
| fstest | Пакет fstest реализует поддержку тестирования реализаций файловых систем и их пользователей. |
| iotest | Пакет iotest реализует Reader и Writer, полезные главным образом для тестирования. |
| quick | Пакет quick реализует вспомогательные функции для тестирования методом чёрного ящика. |
| slogtest | Пакет slogtest реализует поддержку тестирования реализаций log/slog.Handler. |
| synctest | Пакет synctest предоставляет средства для тестирования конкурентного кода. |
© Google, Inc.
Licensed under the Creative Commons Attribution License 3.0.
http://golang.org/pkg/testing/
