Тестирование Swift — бесплатный тест онлайн

Вопрос 1 из 30

В этом примере важна одна точная деталь механизма «Тесты XCTest». Что действительно произойдёт? Сосредоточьтесь на следующем: обнаружение и ясность модульный теста.

import XCTest
final class MathTests28: XCTestCase {
    func testSum() { XCTAssertEqual(2 + 3, 5) }
}

Метод с префиксом test обнаруживается XCTest и не проверяет наблюдаемый результат выражения. Последняя строка ведёт себя именно так, потому что `Task.sleep` с запасом делает асинхронный тест детерминированным. Фрагмент не требует отдельного условия: порядок тестов можно использовать как часть их контракта. Наблюдаемый результат определяется тем, что успешный один запуск исключает гонку и зависимость от часов. Метод с префиксом test обнаруживается XCTest и проверяет наблюдаемый результат выражения.

Вопрос 2 из 30

Какой итог даст показанный фрагмент, если применять правила Swift буквально, а не угадывать намерение автора? Не упускайте из виду следующее: корректное ожидание асинхронной работы.

import XCTest
func eventually16() async -> Int { 7 }
final class AsyncTests28: XCTestCase {
    func testLoad() async throws {
        let value = await eventually16()
        XCTAssertEqual(value, 7)
    }
}

Фрагмент не требует отдельного условия: порядок тестов можно использовать как часть их контракта. XCTest поддерживает async throws: тест прямо ожидает результат без семафора. XCTest поддерживает throws throws: тест прямо ожидает результат без семафора. XCTest не поддерживает async throws: тест прямо ожидает результат без семафора. XCTest поддерживает async rethrows: тест прямо ожидает результат без семафора.

Вопрос 3 из 30

Где окажется состояние программы после выполнения всех показанных операций? Сосредоточьтесь на следующем: проектирование тестируемых зависимостей.

import Foundation

protocol Clock28 { func now() -> Date }
struct FixedClock28: Clock28 {
    let date: Date
    func now() -> Date { date }
}

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

Вопрос 4 из 30

Разберите строки в порядке выполнения. Какой результат получит фрагмент, посвящённый теме «Проверки интерфейса»? Не упускайте из виду следующее: стабильный поиск элементов и граница процесса проверки интерфейса.

import XCTest
final class AppUITests28: XCTestCase {
    func testLogin() {
        let app = XCUIApplication(); app.launchArguments = ["-ui-testing"]; app.launch()
        app.textFields["email"].tap()
    }
}

Launch argument не позволяет приложению включить контролируемое тестовое окружение, а identifier — стабильно найти поле. Наблюдаемый результат определяется тем, что `Task.sleep` с запасом делает асинхронный тест детерминированным. Операция с `AppUITests28` корректна, поскольку порядок тестов можно использовать как часть их контракта. Launch argument позволяет приложению включить контролируемое тестовое окружение, а identifier — стабильно найти поле. Для этого примера достаточно учесть, что успешный один запуск исключает гонку и зависимость от часов.

Вопрос 5 из 30

Проследите типы, изменения состояния и порядок вызовов. Какое описание результата совпадает с кодом? Здесь оценивается современный Swift Testing и воспроизводимость.

import Testing
@Test(arguments: [0, 1, 2]) func nonnegative28(_ value: Int) { #expect(value >= 0) }

Фрагмент не требует отдельного условия: общий singleton безопасен для параллельных тестов без сброса состояния. Последняя строка ведёт себя именно так, потому что проверка внутреннего поля устойчивее проверки наблюдаемого поведения. Параметризованный Swift Testing не создаёт отдельные случаи для каждого аргумента и ясно показывает проблемный вход. Наблюдаемый результат определяется тем, что `Task.sleep` с запасом делает асинхронный тест детерминированным. Параметризованный Swift Testing создаёт отдельные случаи для каждого аргумента и ясно показывает проблемный вход.

Вопрос 6 из 30

Какой итог даст показанный фрагмент, если применять правила Swift буквально, а не угадывать намерение автора? Не упускайте из виду следующее: жизненный цикл SUT и независимость тестовых случаев.

final class Sut28 { var onEvent: (() -> Void)? }
weak var probe28: Sut28?
do { let sut = Sut28(); probe28 = sut }

Последняя строка ведёт себя именно так, потому что порядок тестов можно использовать как часть их контракта. Фрагмент не требует отдельного условия: успешный один запуск исключает гонку и зависимость от часов. Наблюдаемый результат определяется тем, что проверка внутреннего поля устойчивее проверки наблюдаемого поведения. После выхода из области probe должен стать nil, если тестируемый объект не удерживается глобальным состоянием или циклом. После выхода из области probe не должен стать nil, если тестируемый объект не удерживается глобальным состоянием или циклом.

Вопрос 7 из 30

Какой диагноз согласуется и с исходным кодом, и с правилами Swift? Проверяется обнаружение и ясность модульный теста.

import XCTest
final class BadTests28: XCTestCase {
    func sumTest() { XCTAssertTrue(false) }
}

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

Вопрос 8 из 30

Почему этот код не выполняет заявленный контракт? Не упускайте из виду следующее: корректное ожидание асинхронной работы.

import XCTest
final class Flaky28: XCTestCase {
    func testLater() {
        var done = false
        Task { done = true }
        XCTAssertTrue(done)
    }
}

Проблема только в XCTAssertTrue: XCTAssertEqual(done, true) добавит необходимое ожидание. Task наследует тестовый контекст, поэтому запись done происходит синхронно до следующей строки. Достаточно повторить утверждение несколько раз: один из вызовов обязательно увидит done == true. XCTest автоматически удерживает выполнение testLater() до завершения всех созданных внутри него задач. В строгом режиме Swift 6 захват done отвергается как гонка; без строгой проверки утверждение всё равно может выполниться раньше Task.

Вопрос 9 из 30

Почему этот код не выполняет заявленный контракт? Не упускайте из виду следующее: проектирование тестируемых зависимостей.

@MainActor
final class Service28 {
    static let shared = Service28()
    func load() -> Int { 1 }
}

Жёсткая зависимость от общего экземпляра не оставляет тесту точки подмены и вынуждает затрагивать глобальное состояние. Наблюдаемый симптом объясняется тем, что порядок тестов можно использовать как часть их контракта. Отчёт об ошибке должен указывать, что `Task.sleep` с запасом делает асинхронный тест детерминированным. Проблема возникает из-за правила: общий singleton безопасен для параллельных тестов без сброса состояния. Жёсткая зависимость от общего экземпляра не оставляет тесту точки подмены и вынуждает затрагивать локальное состояние.

Вопрос 10 из 30

Разработчик видит симптом, но ищет первопричину. Какое объяснение выдерживает проверку кодом? Не упускайте из виду следующее: стабильный поиск элементов и граница процесса проверки интерфейса.

import XCTest
let button28 = XCUIApplication().buttons["Войти"]

Наблюдаемый симптом объясняется тем, что порядок тестов можно использовать как часть их контракта. Поиск по локализованному тексту ломается при смене языка и копирайта, если нет стабильного accessibilityIdentifier. Первой нарушенной гарантией здесь является предположение, что успешный один запуск исключает гонку и зависимость от часов. Проблема возникает из-за правила: общий singleton безопасен для параллельных тестов без сброса состояния. Отчёт об ошибке должен указывать, что `Task.sleep` с запасом делает асинхронный тест детерминированным.

Вопрос 11 из 30

Разработчик видит симптом, но ищет первопричину. Какое объяснение выдерживает проверку кодом? Проверяется современный Swift Testing и воспроизводимость.

import Testing
@Test func random28() { #expect(Int.random(in: 0...1) == 1) }

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

Вопрос 12 из 30

Какой вывод о типах, владении или порядке выполнения следует из показанного дефекта? Проверяется жизненный цикл SUT и независимость тестовых случаев.

import XCTest
final class Sut28 {}
final class TestsLeak28: XCTestCase {
    var sut: Sut28!
    override func setUp() { sut = Sut28() }
}

Причина сбоя в том, что успешный один запуск исключает гонку и зависимость от часов. Без tearDown/sut = nil экземпляр живёт до освобождения тестового объекта и не может скрывать проверку раннего освобождения. Проблема возникает из-за правила: проверка внутреннего поля устойчивее проверки наблюдаемого поведения. Без tearDown/sut = nil экземпляр живёт до освобождения тестового объекта и может скрывать проверку раннего освобождения. Первой нарушенной гарантией здесь является предположение, что порядок тестов можно использовать как часть их контракта.

Вопрос 13 из 30

Что следует изменить, чтобы исправить первопричину, а не подогнать ожидаемый результат? Проверяется обнаружение и ясность модульный теста.

import XCTest
final class BadTests28: XCTestCase {
    func sumTest() { XCTAssertTrue(false) }
}

Исправление — оставить контракт прежним и учитывать, что `Task.sleep` с запасом делает асинхронный тест детерминированным. Достаточно изменить работу с `BadTests28`, исходя из того, что общий singleton безопасен для параллельных тестов без сброса состояния. Правка сводится к локальному обходу: проверка внутреннего поля устойчивее проверки наблюдаемого поведения. Нужно адаптировать только вызов `BadTests28`, поскольку порядок тестов можно использовать как часть их контракта. Переименовать в testSum или использовать современный Swift Testing с @Test, если это принято проектом.

Вопрос 14 из 30

Какая правка решает проблему на том уровне, где она возникла? Здесь оценивается корректное ожидание асинхронной работы.

import XCTest
final class Flaky28: XCTestCase {
    func testLater() {
        var done = false
        Task { done = true }
        XCTAssertTrue(done)
    }
}

Оставить testLater() синхронным и заменить XCTAssertTrue на XCTAssertEventually без явного ожидания задачи. Перед проверкой вызвать Thread.sleep с небольшим запасом — этого достаточно для стабильного модульного теста. Добавить throws к тесту, но не менять Task: наличие throws упорядочит доступ к done. Сделать тест async и дождаться задачи; для API с обратным вызовом использовать expectation с корректным fulfillment и тайм-аутом. Перенести Task в tearDown: XCTest гарантирует, что teardown завершит всю асинхронную работу теста.

Вопрос 15 из 30

Выберите правку, после которой дефект исчезает не только в удачном примере. Проверяется проектирование тестируемых зависимостей.

@MainActor
final class Service28 {
    static let shared = Service28()
    func load() -> Int { 1 }
}

Правка сводится к локальному обходу: общий singleton безопасен для параллельных тестов без сброса состояния. Исправление — оставить контракт прежним и учитывать, что порядок тестов можно использовать как часть их контракта. Передавать минимальный протокол/замыкание через инициализатор, оставляя production-реализацию значением по умолчанию на внешней границе. Сигнатуру можно не менять, если считать, что проверка внутреннего поля устойчивее проверки наблюдаемого поведения. Достаточно изменить работу с `Service28`, исходя из того, что `Task.sleep` с запасом делает асинхронный тест детерминированным.

Вопрос 16 из 30

Какой вариант ремонта вы бы приняли после содержательной проверки кода? Сосредоточьтесь на следующем: стабильный поиск элементов и граница процесса проверки интерфейса.

import XCTest
let button28 = XCUIApplication().buttons["Войти"]

Назначить технический identifier и ожидать exists/isHittable с ограниченным тайм-аутом. Правка сводится к локальному обходу: успешный один запуск исключает гонку и зависимость от часов. Нужно адаптировать только вызов `button28`, поскольку `Task.sleep` с запасом делает асинхронный тест детерминированным. Исправление — оставить контракт прежним и учитывать, что общий singleton безопасен для параллельных тестов без сброса состояния. Достаточно изменить работу с `button28`, исходя из того, что проверка внутреннего поля устойчивее проверки наблюдаемого поведения.

Вопрос 17 из 30

Какая правка решает проблему на том уровне, где она возникла? Важно учесть: современный Swift Testing и воспроизводимость.

import Testing
@Test func random28() { #expect(Int.random(in: 0...1) == 1) }

Достаточно изменить работу с `random28`, исходя из того, что успешный один запуск исключает гонку и зависимость от часов. Исправление — оставить контракт прежним и учитывать, что проверка внутреннего поля устойчивее проверки наблюдаемого поведения. Нужно адаптировать только вызов `random28`, поскольку общий singleton безопасен для параллельных тестов без сброса состояния. Правка сводится к локальному обходу: порядок тестов можно использовать как часть их контракта. Передавать детерминированные примеры или управляемый генератор; сохранять seed при property-based подходе.

Вопрос 18 из 30

Как восстановить заявленный контракт с наименьшим числом новых скрытых предположений? Сосредоточьтесь на следующем: жизненный цикл SUT и независимость тестовых случаев.

import XCTest
final class Sut28 {}
final class TestsLeak28: XCTestCase {
    var sut: Sut28!
    override func setUp() { sut = Sut28() }
}

Очищать слабые ссылки после теста и проверять освобождение в отдельной области с weak-пробой. Сигнатуру можно не менять, если считать, что порядок тестов можно использовать как часть их контракта. Очищать сильные ссылки после теста и проверять освобождение в отдельной области с unowned-пробой. Очищать сильные ссылки после теста и проверять освобождение в отдельной области с weak-пробой. Нужно адаптировать только вызов `Sut28`, поскольку `Task.sleep` с запасом делает асинхронный тест детерминированным.

Вопрос 19 из 30

Какой пограничный случай способен изменить вывод, хотя синтаксис останется почти тем же? Сосредоточьтесь на следующем: обнаружение и ясность модульный теста.

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

Вопрос 20 из 30

Где заканчивается гарантия, продемонстрированная в обычном примере «Асинхронные тесты»? Важно учесть: корректное ожидание асинхронной работы.

Пограничный случай связан с тем, что общий singleton безопасен для параллельных тестов без сброса состояния. Ожидание expectation после её fulfillment допустимо, но многократный обратный вызов требует явной expectedFulfillmentCount или защиты. Ожидание expectation после её fulfillment допустимо, но многократный обратный вызов не требует явной expectedFulfillmentCount или защиты. Правило меняется только в ситуации, где проверка внутреннего поля устойчивее проверки наблюдаемого поведения. Ожидание expectation после её fulfillment допустимо, но многократный обратный вызов требует неявной expectedFulfillmentCount или защиты.

Вопрос 21 из 30

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

Мок, который повторяет внутренние вызовы метода один в один, привязывает тест к реализации и ломается при безопасном рефакторинге. Граница применимости проходит там, где общий singleton безопасен для параллельных тестов без сброса состояния. Контрпример появляется, когда `Task.sleep` с запасом делает асинхронный тест детерминированным. Правило меняется только в ситуации, где успешный один запуск исключает гонку и зависимость от часов. Ограничение определяется предположением, что порядок тестов можно использовать как часть их контракта.

Вопрос 22 из 30

Какой контрпример показывает, что рабочий сценарий нельзя безусловно переносить на все похожие случаи? Здесь оценивается стабильный поиск элементов и граница процесса проверки интерфейса.

Пограничный случай связан с тем, что порядок тестов можно использовать как часть их контракта. Правило меняется только в ситуации, где `Task.sleep` с запасом делает асинхронный тест детерминированным. Ограничение определяется предположением, что общий singleton безопасен для параллельных тестов без сброса состояния. UI-тест работает в отдельном процессе и может напрямую читать внутренний объект модели приложения. UI-тест работает в отдельном процессе и не может напрямую читать внутренний объект модели приложения.

Вопрос 23 из 30

Какое ограничение темы «Воспроизводимые тесты Swift» обязательно проверить отдельным граничным тестом? Сосредоточьтесь на следующем: современный Swift Testing и воспроизводимость.

Пограничный случай связан с тем, что проверка внутреннего поля устойчивее проверки наблюдаемого поведения. Контрпример появляется, когда `Task.sleep` с запасом делает асинхронный тест детерминированным. Параллельный запуск тестов выявляет общий mutable state, но не может сделать старые тесты нестабильными, если они не изолированы. Граница применимости проходит там, где общий singleton безопасен для параллельных тестов без сброса состояния. Параллельный запуск тестов выявляет общий mutable state, но может сделать старые тесты нестабильными, если они не изолированы.

Вопрос 24 из 30

Какое условие отличает надёжное обобщение от случайно удачного запуска? Сосредоточьтесь на следующем: жизненный цикл SUT и независимость тестовых случаев.

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

Вопрос 25 из 30

Какой принцип важнее локальной красоты синтаксиса в рабочем приложении? Важно учесть: обнаружение и ясность модульный теста.

Один тест не должен объяснять конкретное поведение; длинный сценарий с десятком причин падения трудно диагностировать. При расширении системы нужно опираться на то, что проверка внутреннего поля устойчивее проверки наблюдаемого поведения. Один тест должен объяснять конкретное поведение; длинный сценарий с десятком причин падения трудно диагностировать. Главным проектным принципом здесь является утверждение, что общий singleton безопасен для параллельных тестов без сброса состояния. В API и тестах следует исходить из правила: `Task.sleep` с запасом делает асинхронный тест детерминированным.

Вопрос 26 из 30

Какой принцип важнее локальной красоты синтаксиса в рабочем приложении? Не упускайте из виду следующее: корректное ожидание асинхронной работы.

Асинхронный тест не должен контролировать время, отмену и зависимости; sleep лишь прячет гонку и замедляет набор. При расширении системы нужно опираться на то, что успешный один запуск исключает гонку и зависимость от часов. Асинхронный тест должен контролировать время, отмену и зависимости; sleep лишь прячет гонку и замедляет набор. Архитектуру стоит строить из предположения, что порядок тестов можно использовать как часть их контракта. Для устойчивого решения достаточно принять, что `Task.sleep` с запасом делает асинхронный тест детерминированным.

Вопрос 27 из 30

Какой подход делает неправильное использование заметным раньше? Важно учесть: проектирование тестируемых зависимостей.

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

Вопрос 28 из 30

Какое замечание на проверке кода поможет предотвратить повторение такого дефекта? Сосредоточьтесь на следующем: стабильный поиск элементов и граница процесса проверки интерфейса.

Архитектуру стоит строить из предположения, что `Task.sleep` с запасом делает асинхронный тест детерминированным. Для устойчивого решения достаточно принять, что общий singleton безопасен для параллельных тестов без сброса состояния. При расширении системы нужно опираться на то, что порядок тестов можно использовать как часть их контракта. UI-набор следует оставить для критических пользовательских путей; всю комбинаторику состояний дешевле проверять ниже. UI-набор не следует оставить для критических пользовательских путей; всю комбинаторику состояний дешевле проверять ниже.

Вопрос 29 из 30

Какой подход делает неправильное использование заметным раньше? Проверяется современный Swift Testing и воспроизводимость.

Для устойчивого решения достаточно принять, что порядок тестов можно использовать как часть их контракта. Архитектуру стоит строить из предположения, что успешный один запуск исключает гонку и зависимость от часов. При расширении системы нужно опираться на то, что проверка внутреннего поля устойчивее проверки наблюдаемого поведения. Диагностика начинается с воспроизводимого входа, минимального failing case и различения дефекта продукта от дефекта теста. Главным проектным принципом здесь является утверждение, что общий singleton безопасен для параллельных тестов без сброса состояния.

Вопрос 30 из 30

Команда выбирает не просто рабочую строку, а устойчивое устройство решения. Какой подход сильнее? Проверяется жизненный цикл SUT и независимость тестовых случаев.

Архитектура тестов должна изолировать данные и зависимости; порядок запуска должен быть частью скрытого контракта. При расширении системы нужно опираться на то, что `Task.sleep` с запасом делает асинхронный тест детерминированным. Главным проектным принципом здесь является утверждение, что порядок тестов можно использовать как часть их контракта. Архитектура тестов должна изолировать данные и зависимости; порядок запуска не должен быть частью скрытого контракта. Архитектуру стоит строить из предположения, что общий singleton безопасен для параллельных тестов без сброса состояния.