Тесты и табличные сценарии — бесплатный тест онлайн

Вопрос 1 из 30

Перед публикацией кода по теме «Пакет testing» нужно уточнить контракт. Что увидит вызывающий код после выполнения?

// Фрагмент для трассировки.
package sample
import "testing"
func assertEqual(t *testing.T,a,b int){t.Helper();if a!=b{t.Fatalf("%d != %d",a,b)}}
func TestX(t *testing.T){assertEqual(t,2,2)}

Каждый случай получает отдельное имя и отчёт, а параллельные случаи не должны делить изменяемый вход. Ошибка из `assertEqual` указывает на строку теста после вызова `t.Helper()`, а не на внутреннюю строку помощника. Цикл запускает три набора одной функции без копирования логики проверки. Функция времени инъецируется полем и в тесте возвращает фиксированный момент. Цикл напечатает `0 1 2`, после чего `break` завершит только самую внутреннюю конструкцию `for`.

Вопрос 2 из 30

В рабочем примере по теме «Пакет testing» важно отделить гарантию от догадки. Как подготовить этот код к реальному использованию?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package sample
import "testing"
func assertEqual(t *testing.T,a,b int){t.Helper();if a!=b{t.Fatalf("%d != %d",a,b)}}
func TestX(t *testing.T){assertEqual(t,2,2)}

Создавать локальную копию данных случая там, где версия языка или форма цикла допускает захват изменяемой переменной. Добавлять граничные и ошибочные случаи, давать имена по поведению, а не `case1`. Определять контракт со стороны потребителя и использовать простую ручную заглушку для нескольких методов. Останавливать тест через `Fatal` только когда дальнейшие проверки не имеют смысла, иначе собирать несколько независимых ошибок. Проверять `nil`-получатель только если методы типа действительно обещают осмысленное поведение для `nil`.

Вопрос 3 из 30

Фрагмент относится к теме «Пакет testing». Какой контракт определяет результат показанного кода?

// Определите правило Go, которое объясняет результат.
package sample
import "testing"
func assertEqual(t *testing.T,a,b int){t.Helper();if a!=b{t.Fatalf("%d != %d",a,b)}}
func TestX(t *testing.T){assertEqual(t,2,2)}

Таблица объединяет вход, ожидаемый результат и имя случая; каждый случай должен быть самостоятельным и читаемым. `t.Run` создаёт именованный подтест; после `t.Parallel` он продолжает параллельно только после приостановки родительской последовательной части. Комментарий экспортированного имени объясняет назначение, контракт, ошибки и конкурентную безопасность, а не повторяет сигнатуру. Лучше подменять узкую зависимость через интерфейс или функцию, чем имитировать весь внешний пакет. Тестовая функция имеет сигнатуру `func TestX(*testing.T)`; `t.Helper` переносит место ошибки к вызывающему помощнику.

Вопрос 4 из 30

На ревью разбирают тему «Пакет testing». Какое допущение здесь чаще всего оказывается ложным?

Глобальная замена функции ломает параллельные тесты и создаёт скрытую зависимость порядка. Параллельный подтест может пережить цикл родителя и обнаружить общий временный файл или глобальную настройку. Проверка `len(ch)==0` перед чтением не защищает от изменения состояния другой горутиной. `Fatal` завершает текущую горутину через `runtime.Goexit` и должен вызываться из горутины теста, а не произвольного работника. Общая изменяемая структура входа может быть испорчена предыдущим случаем и сделать порядок важным.

Вопрос 5 из 30

В разделе «Пакет testing» показан конкретный случай. Какое замечание о цене решения будет точным?

Фиксация версий делает сборку повторяемой, но слишком редкие обновления накапливают риски миграции и уязвимости. Параллельность ускоряет независимые случаи, но усложняет ресурсы, журналы и воспроизводимость порядка. Небольшие помощники уменьшают повтор, но слишком умная тестовая библиотека может скрыть важные условия. Таблица хорошо показывает одинаковый контракт, но сильно разные сценарии лучше оставить отдельными тестами. Узкая подмена делает тест точным, но слишком много интерфейсов ради тестов дробит простой код.

Вопрос 6 из 30

В рабочем примере по теме «Табличные сценарии» важно отделить гарантию от догадки. Что гарантированно произойдёт в показанной последовательности операций?

// Фрагмент для трассировки.
package sample
import "testing"
func TestAbs(t *testing.T){cases:=[]struct{name string;in,want int}{{"negative",-2,2},{"zero",0,0},{"positive",3,3}};for _,tc:=range cases{t.Run(tc.name,func(t *testing.T){got:=tc.in;if got<0{got=-got};if got!=tc.want{t.Fatal(got)}})}}

Каждый случай получает отдельное имя и отчёт, а параллельные случаи не должны делить изменяемый вход. Ошибка из `assertEqual` указывает на строку теста после вызова `t.Helper()`, а не на внутреннюю строку помощника. Перевод между счетами защищает проверку остатка и обе записи одной парой блокировок. Цикл запускает три набора одной функции без копирования логики проверки. Функция времени инъецируется полем и в тесте возвращает фиксированный момент.

Вопрос 7 из 30

Фрагмент относится к теме «Табличные сценарии». Какой вариант исправления соответствует обычной практике Go?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package sample
import "testing"
func TestAbs(t *testing.T){cases:=[]struct{name string;in,want int}{{"negative",-2,2},{"zero",0,0},{"positive",3,3}};for _,tc:=range cases{t.Run(tc.name,func(t *testing.T){got:=tc.in;if got<0{got=-got};if got!=tc.want{t.Fatal(got)}})}}

Определять контракт со стороны потребителя и использовать простую ручную заглушку для нескольких методов. Создавать локальную копию данных случая там, где версия языка или форма цикла допускает захват изменяемой переменной. Останавливать тест через `Fatal` только когда дальнейшие проверки не имеют смысла, иначе собирать несколько независимых ошибок. Использовать встраивание для композиции поведения, а не для имитации наследования и неявной подстановки типов. Добавлять граничные и ошибочные случаи, давать имена по поведению, а не `case1`.

Вопрос 8 из 30

На ревью разбирают тему «Табличные сценарии». Какой принцип языка объясняет результат полностью?

// Определите правило Go, которое объясняет результат.
package sample
import "testing"
func TestAbs(t *testing.T){cases:=[]struct{name string;in,want int}{{"negative",-2,2},{"zero",0,0},{"positive",3,3}};for _,tc:=range cases{t.Run(tc.name,func(t *testing.T){got:=tc.in;if got<0{got=-got};if got!=tc.want{t.Fatal(got)}})}}

Таблица объединяет вход, ожидаемый результат и имя случая; каждый случай должен быть самостоятельным и читаемым. Лучше подменять узкую зависимость через интерфейс или функцию, чем имитировать весь внешний пакет. Тестовая функция имеет сигнатуру `func TestX(*testing.T)`; `t.Helper` переносит место ошибки к вызывающему помощнику. Ошибка — значение, обычно возвращаемое отдельным результатом; `errors.New` подходит для постоянного сообщения без форматирования. `t.Run` создаёт именованный подтест; после `t.Parallel` он продолжает параллельно только после приостановки родительской последовательной части.

Вопрос 9 из 30

В разделе «Табличные сценарии» показан конкретный случай. Какой предел контракта важен для вызывающего кода?

`Fatal` завершает текущую горутину через `runtime.Goexit` и должен вызываться из горутины теста, а не произвольного работника. Глобальная замена функции ломает параллельные тесты и создаёт скрытую зависимость порядка. Параллельный подтест может пережить цикл родителя и обнаружить общий временный файл или глобальную настройку. Сравнивать структуру оператором `==` можно только тогда, когда сравнимы все её поля. Общая изменяемая структура входа может быть испорчена предыдущим случаем и сделать порядок важным.

Вопрос 10 из 30

Команда проверяет решение по теме «Табличные сценарии». Как решение скажется на тестировании и дальнейших изменениях?

Узкая подмена делает тест точным, но слишком много интерфейсов ради тестов дробит простой код. Небольшие помощники уменьшают повтор, но слишком умная тестовая библиотека может скрыть важные условия. Параллельность ускоряет независимые случаи, но усложняет ресурсы, журналы и воспроизводимость порядка. Таблица хорошо показывает одинаковый контракт, но сильно разные сценарии лучше оставить отдельными тестами. Явное разыменование показывает мутацию, но API с множеством указателей часто сигнализирует о неясном владении.

Вопрос 11 из 30

Фрагмент относится к теме «Подтесты». Какое наблюдение о работе кода будет верным?

// Фрагмент для трассировки.
package sample
import "testing"
func TestCases(t *testing.T){for _,name:=range []string{"a","b"}{name:=name;t.Run(name,func(t *testing.T){t.Parallel();_ = name})}}

Цикл запускает три набора одной функции без копирования логики проверки. Функция времени инъецируется полем и в тесте возвращает фиксированный момент. Каждый случай получает отдельное имя и отчёт, а параллельные случаи не должны делить изменяемый вход. Каждое значение получает один из работников, а порядок результатов не обязан совпадать с входом. Ошибка из `assertEqual` указывает на строку теста после вызова `t.Helper()`, а не на внутреннюю строку помощника.

Вопрос 12 из 30

На ревью разбирают тему «Подтесты». Какую правку разумнее внести до объединения изменений?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package sample
import "testing"
func TestCases(t *testing.T){for _,name:=range []string{"a","b"}{name:=name;t.Run(name,func(t *testing.T){t.Parallel();_ = name})}}

Создавать локальную копию данных случая там, где версия языка или форма цикла допускает захват изменяемой переменной. Документировать мутацию входного среза или принимать копию, если функция обещает не менять данные вызывающего кода. Добавлять граничные и ошибочные случаи, давать имена по поведению, а не `case1`. Определять контракт со стороны потребителя и использовать простую ручную заглушку для нескольких методов. Останавливать тест через `Fatal` только когда дальнейшие проверки не имеют смысла, иначе собирать несколько независимых ошибок.

Вопрос 13 из 30

В разделе «Подтесты» показан конкретный случай. Какое правило Go непосредственно объясняет поведение фрагмента?

// Определите правило Go, которое объясняет результат.
package sample
import "testing"
func TestCases(t *testing.T){for _,name:=range []string{"a","b"}{name:=name;t.Run(name,func(t *testing.T){t.Parallel();_ = name})}}

Таблица объединяет вход, ожидаемый результат и имя случая; каждый случай должен быть самостоятельным и читаемым. Лучше подменять узкую зависимость через интерфейс или функцию, чем имитировать весь внешний пакет. `t.Run` создаёт именованный подтест; после `t.Parallel` он продолжает параллельно только после приостановки родительской последовательной части. Инициализирующая часть `if` создаёт переменные, доступные в условии и обеих ветвях, но не после конструкции. Тестовая функция имеет сигнатуру `func TestX(*testing.T)`; `t.Helper` переносит место ошибки к вызывающему помощнику.

Вопрос 14 из 30

Команда проверяет решение по теме «Подтесты». Где заканчивается гарантия показанного приёма?

Параллельный подтест может пережить цикл родителя и обнаружить общий временный файл или глобальную настройку. Увеличение числа горутин при одном глобальном мьютексе часто лишь увеличивает очередь. Общая изменяемая структура входа может быть испорчена предыдущим случаем и сделать порядок важным. `Fatal` завершает текущую горутину через `runtime.Goexit` и должен вызываться из горутины теста, а не произвольного работника. Закрытие входного канала из потребителя может паниковать в активном производителе.

Вопрос 15 из 30

Перед публикацией кода по теме «Подтесты» нужно уточнить контракт. Когда этот приём помогает, а когда начинает мешать?

Небольшие помощники уменьшают повтор, но слишком умная тестовая библиотека может скрыть важные условия. Таблица хорошо показывает одинаковый контракт, но сильно разные сценарии лучше оставить отдельными тестами. Параллельность ускоряет независимые случаи, но усложняет ресурсы, журналы и воспроизводимость порядка. Подробные метки ускоряют срезы, но стоимость и устойчивость системы мониторинга требуют заранее ограниченного словаря. Узкая подмена делает тест точным, но слишком много интерфейсов ради тестов дробит простой код.

Вопрос 16 из 30

На ревью разбирают тему «Подмены». Каков наблюдаемый результат этого кода?

// Фрагмент для трассировки.
package main
import "time"
type Clock func() time.Time
func age(now Clock,t time.Time)time.Duration{return now().Sub(t)}
func main(){}

Ошибка из `assertEqual` указывает на строку теста после вызова `t.Helper()`, а не на внутреннюю строку помощника. Функция времени инъецируется полем и в тесте возвращает фиксированный момент. Каждый случай получает отдельное имя и отчёт, а параллельные случаи не должны делить изменяемый вход. Цикл запускает три набора одной функции без копирования логики проверки. `makeInt` возвращает корректный указатель; значение не исчезает после выхода из функции.

Вопрос 17 из 30

В разделе «Подмены» показан конкретный случай. Какое изменение лучше всего укрепит контракт этого фрагмента?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package main
import "time"
type Clock func() time.Time
func age(now Clock,t time.Time)time.Duration{return now().Sub(t)}
func main(){}

Определять контракт со стороны потребителя и использовать простую ручную заглушку для нескольких методов. Останавливать тест через `Fatal` только когда дальнейшие проверки не имеют смысла, иначе собирать несколько независимых ошибок. Создавать локальную копию данных случая там, где версия языка или форма цикла допускает захват изменяемой переменной. Добавлять граничные и ошибочные случаи, давать имена по поведению, а не `case1`. Нормализовать пути осторожно, явно ограничивать методы и централизовать декодирование параметров.

Вопрос 18 из 30

Команда проверяет решение по теме «Подмены». Какое утверждение точнее всего описывает действующую гарантию?

// Определите правило Go, которое объясняет результат.
package main
import "time"
type Clock func() time.Time
func age(now Clock,t time.Time)time.Duration{return now().Sub(t)}
func main(){}

Публичный пакет проверяют как внутренними тестами, так и внешним пакетом `_test`, примерами и тестами совместимости ошибок. Лучше подменять узкую зависимость через интерфейс или функцию, чем имитировать весь внешний пакет. Таблица объединяет вход, ожидаемый результат и имя случая; каждый случай должен быть самостоятельным и читаемым. Тестовая функция имеет сигнатуру `func TestX(*testing.T)`; `t.Helper` переносит место ошибки к вызывающему помощнику. `t.Run` создаёт именованный подтест; после `t.Parallel` он продолжает параллельно только после приостановки родительской последовательной части.

Вопрос 19 из 30

Перед публикацией кода по теме «Подмены» нужно уточнить контракт. Что может изменить вывод при небольшом изменении условий?

`Fatal` завершает текущую горутину через `runtime.Goexit` и должен вызываться из горутины теста, а не произвольного работника. Общая изменяемая структура входа может быть испорчена предыдущим случаем и сделать порядок важным. Отрицательный счётчик вызывает панику; повторное использование возможно только после завершившегося `Wait` и нового независимого набора. Круговой тест может скрыть одинаковую ошибку кодировщика и декодировщика, поэтому нужен независимый ожидаемый внешний вид. Глобальная замена функции ломает параллельные тесты и создаёт скрытую зависимость порядка.

Вопрос 20 из 30

В рабочем примере по теме «Подмены» важно отделить гарантию от догадки. Как решение влияет на читаемость и надёжность?

Небольшие помощники уменьшают повтор, но слишком умная тестовая библиотека может скрыть важные условия. Глубокая readiness точнее отражает способность обслуживать, но слишком дорогая проверка сама может перегрузить зависимости. Параллельность ускоряет независимые случаи, но усложняет ресурсы, журналы и воспроизводимость порядка. Узкая подмена делает тест точным, но слишком много интерфейсов ради тестов дробит простой код. Таблица хорошо показывает одинаковый контракт, но сильно разные сценарии лучше оставить отдельными тестами.

Вопрос 21 из 30

В разделе «Тестирование и наблюдаемость» показан конкретный случай в тесте «Тесты и табличные сценарии». Что увидит вызывающий код после выполнения?

go test -race -shuffle=on -count=10 ./...

Тест отменяет контекст после первого результата и убеждается, что выход закрывается за ограниченное время. Тест ждёт событие по каналу и сообщает отдельную ошибку только если дедлайн действительно истёк. Внешний тест не может обратиться к неэкспортированным полям и тем самым проверяет настоящий контракт пользователя. Тест ошибки проверяет `errors.Is`, а не точное длинное сообщение с контекстом. Тест с тысячей конкурентных увеличений ожидает точное итоговое значение под мьютексом.

Вопрос 22 из 30

Команда проверяет решение по теме «Тестирование и наблюдаемость» в тесте «Тесты и табличные сценарии». Как подготовить этот код к реальному использованию?

go test -race -shuffle=on -count=10 ./...
# Задача: выбрать безопасную правку или способ проверки.

Хранить репрезентативные старые документы в `testdata`, проверять ограничения размера и не журналировать полный чувствительный JSON. Использовать короткий контролируемый таймаут, синхронизацию запуска и отдельную проверку причины завершения. Запускать `-shuffle`, `-count`, `-race`, хранить медленные интеграционные тесты отдельно и анализировать пропуски покрытия по риску. Запускать серии на стабильной машине, фиксировать входы и отдельно следить за p50/p95/p99, CPU, GC и очередями. Добавлять нагрузочные тесты, `-race` и снимки горутин при зависании; число сообщений в очереди использовать только как метрику.

Вопрос 23 из 30

Перед публикацией кода по теме «Тестирование и наблюдаемость» нужно уточнить контракт в тесте «Тесты и табличные сценарии». Какой контракт определяет результат показанного кода?

go test -race -shuffle=on -count=10 ./...
# Требуется объяснить правило, а не только назвать команду.

Панику проверяют в той же горутине через отложенный `recover`, а в рабочем сервисе фиксируют значение и стек. Обобщённый алгоритм тестируют представителями разных ветвей ограничения и именованными типами, а не только `int`. Синхронизацию проверяют под `-race`, повторными прогонами и инвариантами результата, а не только отсутствием паники. Качество набора определяют полезные сценарии и проверяемые свойства, а не только процент покрытия строк. Клиент тестируют через `httptest.Server` и подменный `RoundTripper`, проверяя статусы, тело, отмену и число попыток.

Вопрос 24 из 30

В рабочем примере по теме «Тестирование и наблюдаемость» важно отделить гарантию от догадки в тесте «Тесты и табличные сценарии». Какое допущение здесь чаще всего оказывается ложным?

Высокое покрытие может состоять из тестов без содержательных утверждений. Чистый отчёт не доказывает отсутствие непокрытой гонки; найденный отчёт нельзя «лечить» случайным `Sleep`. Тест, который просто завершается после `recover`, может ложно пройти, если забыта проверка факта паники. Проверка `len(ch)==0` перед чтением не защищает от изменения состояния другой горутиной. Тест только успешного 200 не проверяет закрытие тела, медленные заголовки, разрыв соединения и повтор.

Вопрос 25 из 30

Фрагмент относится к теме «Тестирование и наблюдаемость» в тесте «Тесты и табличные сценарии». Какое замечание о цене решения будет точным?

Большее число инстанцирований повышает уверенность, но не должно превращать тесты в повторение одинаковой арифметики. Золотой файл хорошо ловит изменение формата, но требует осознанного пересмотра, а не автоматического обновления. Случайный порядок ловит зависимость тестов, но найденную нестабильность нужно устранить, а не просто повторять до успеха. Изолированный тест локализует дефект, а тест цепочки ловит ошибки порядка и взаимодействия слоёв. Глубокая readiness точнее отражает способность обслуживать, но слишком дорогая проверка сама может перегрузить зависимости.

Вопрос 26 из 30

Команда проверяет решение по теме «Конкурентность и эксплуатация» в тесте «Тесты и табличные сценарии». Что гарантированно произойдёт в показанной последовательности операций?

// Фрагмент для трассировки.
package sample
import("net";"testing")
func TestPort(t *testing.T){ln,err:=net.Listen("tcp","127.0.0.1:0");if err!=nil{t.Fatal(err)};t.Cleanup(func(){ln.Close()})}

Рост `db.WaitDuration` одновременно с исчерпанием пула указывает на очередь за соединениями, а не на нехватку CPU. Семафор не позволяет одновременно выполнять больше двадцати внешних запросов. Два теста с разными `t.TempDir()` не конфликтуют за один и тот же путь. Десятки горутин могут ждать свободное соединение, даже если процессор почти не занят. Снимок горутин показывает множество работников, ожидающих один и тот же мьютекс.

Вопрос 27 из 30

Перед публикацией кода по теме «Конкурентность и эксплуатация» нужно уточнить контракт в тесте «Тесты и табличные сценарии». Какой вариант исправления соответствует обычной практике Go?

// Фрагмент из ревью: требуется выбрать безопасную правку.
package sample
import("net";"testing")
func TestPort(t *testing.T){ln,err:=net.Listen("tcp","127.0.0.1:0");if err!=nil{t.Fatal(err)};t.Cleanup(func(){ln.Close()})}

Назначать уникальные порты через прослушивание `:0`, не менять глобальное окружение параллельно и закрывать серверы через Cleanup. Ограничивать параллелизм, задавать контекст, отслеживать WaitCount/WaitDuration и избегать запросов N+1. Настраивать лимиты по профилю зависимости, иметь глобальный бюджет и корректно останавливать при выпуске. Ограничивать кардинальность меток, контролировать очередь лимитера и не удерживать глобальную блокировку во время `next`. Сочетать лимит параллелизма, отмену, предохранитель от серии ошибок и метрики насыщения пула.

Вопрос 28 из 30

В рабочем примере по теме «Конкурентность и эксплуатация» важно отделить гарантию от догадки в тесте «Тесты и табличные сценарии». Какой принцип языка объясняет результат полностью?

// Определите правило Go, которое объясняет результат.
package sample
import("net";"testing")
func TestPort(t *testing.T){ln,err:=net.Listen("tcp","127.0.0.1:0");if err!=nil{t.Fatal(err)};t.Cleanup(func(){ln.Close()})}

Параллельные тесты разделяют процесс, глобальные переменные и внешние ресурсы, поэтому изоляция должна быть явной. Ограничение параллелизма и пула соединений защищает и клиент, и удалённый сервис от лавины запросов. Конфигурацию читают и валидируют до запуска рабочих горутин; секреты отделяют от безопасных параметров и не печатают целиком. Middleware выполняется конкурентно для запросов; изменяемые счётчики, кеши и ограничители должны быть безопасны. Каждый запрос обычно обрабатывается конкурентно, поэтому общее состояние обработчика должно быть неизменяемым или синхронизированным.

Вопрос 29 из 30

Фрагмент относится к теме «Конкурентность и эксплуатация» в тесте «Тесты и табличные сценарии». Какой предел контракта важен для вызывающего кода?

Два последовательных этапа с собственными большими буферами могут скрыть минуты накопленной задержки. Мьютекс, удерживаемый вокруг `next`, последовательно обработает весь сервер и может привести к взаимной блокировке. `t.Setenv` нельзя безопасно сочетать с параллельным тестом, потому что окружение общее для процесса. Автоматическая публикация `/debug/pprof` без защиты раскрывает внутреннее состояние сервиса. Нулевые серверные таймауты оставляют процесс уязвимым для очень медленных клиентов.

Вопрос 30 из 30

На ревью разбирают тему «Конкурентность и эксплуатация» в тесте «Тесты и табличные сценарии». Как решение скажется на тестировании и дальнейших изменениях?

Разделение блокировки повышает параллелизм, но может разрушить единый инвариант и усложнить код. Глобальный лимит защищает процесс, но справедливость между маршрутами может потребовать отдельных квот. Параллельность сокращает время CI, но внешняя база или лимит CPU могут стать общим узким местом. Больший параллелизм повышает пропускную способность до точки насыщения, после которой растут очереди и ошибки. Жёсткие лимиты защищают ёмкость, но должны учитывать законные большие загрузки и потоковые ответы.