Sealed class и исчерпывающие модели — бесплатный тест онлайн

Вопрос 1 из 25

Что точнее описывает механику фрагмента «Добавление нового варианта»?

// На ревью требуется объяснить причину поведения.
sealed interface Payment
data class Card(val last4: String) : Payment
data object Cash : Payment

fun audit(p: Payment) = when (p) {
    is Card -> "card:${p.last4}"
    Cash -> "cash"
}

Здесь действует следующее правило: Добавить общий else во все when, чтобы новая ветвь не требовала изменений. Из правил языка или API следует, что сделать BankTransfer наследником Card, чтобы старые ветви считали его картой. Ключевым считают контракт: Сначала выпустить новый JSON, а код потребителей оставить до первого реального перевода. Изменение закрытой иерархии является контролируемым изменением контракта; компилятор находит исходные потребители, но не внешние данные. Механика примера описывается утверждением: Заменить sealed interface на Any и проверять строки имён классов.

Вопрос 2 из 25

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

// Сохраните назначение фрагмента, но укрепите его контракт.
sealed interface Command
data object Start : Command
data object Stop : Command
data class SetRate(val value: Int) : Command

fun apply(c: Command): String = when (c) {
    Start -> "started"
    Stop -> "stopped"
    is SetRate -> require(c.value > 0).let { "rate=${c.value}" }
}

Сохранить API и считать достаточным условие: Полезнее проверить `toString` всех вариантов, не вызывая apply. Обернуть операцию проверкой и не менять основной контракт: Один тест Start достаточен, потому что when уже проверяет все ветви. Передать ответственность владельцу вызова, предполагая, что нужен только тест, что отрицательное значение бросает любое исключение. Зафиксировать текущее поведение регрессионным тестом: Следует мокировать каждый data object, не создавая реальных команд. Сочетать по одному содержательному примеру на вариант с граничными тестами данных внутри параметризованных подтипов.

Вопрос 3 из 25

На каком входе или состоянии граница «Эволюция sealed-состояния» становится заметной?

Наследник sealed-типа, объявленный `open`, способен иметь неизвестные подклассы; исчерпывание идёт по известным прямым ветвям. Добавить регрессию на гипотезу: Новый вариант автоматически попадёт в ветвь Loading. Считать опасной границей ситуацию, где функция продолжит компилироваться и вернёт пустую строку. Зафиксировать сценарий, где ожидается: Sealed-иерархию нельзя расширять после первого объявления даже в исходном модуле. Проверить крайний ввод, при котором ошибка появится только при первом объекте Empty во время выполнения.

Вопрос 4 из 25

Какова практическая цена решения «Smart cast в ветви when»: Ставить более специфичные проверки до широких и выбирать названия ветвей, отражающие предметный смысл, а не только класс?

Компромисс состоит в утверждении: When создаёт новый объект подтипа перед выполнением ветви. Практическое ограничение подхода: Ветка Error выполняется первой для любого исключения в Ok. Цена упрощения проявится, если обе ветви получают статический тип Any, потому что Result — интерфейс. После внедрения придётся исходить из того, что smart cast возникает только после ручного `as Ok`. Один `when` делает переходы видимыми, но повторение одинакового разбора по слоям сигнализирует о неверной границе ответственности.

Вопрос 5 из 25

Какое свойство модели помогает избежать невозможных сочетаний флагов?

// Проследите фактическое выполнение без изменения кода.
sealed interface Checkout
data object Idle : Checkout
data class Editing(val total: Int) : Checkout
data class Paying(val requestId: String) : Checkout
data class Done(val receipt: String) : Checkout

fun canEdit(s: Checkout) = s is Idle || s is Editing

Иерархия сохраняет историю предыдущих состояний внутри каждого объекта. Sealed автоматически синхронизирует изменение состояния между потоками. Data class запрещает создать два состояния одновременно в разных объектах. Каждый объект представляет одно состояние и содержит только допустимые для него данные. Компилятор проверяет допустимость всех переходов между подтипами без дополнительного кода.

Вопрос 6 из 25

Что добавить в регрессионный набор для «Тестирование закрытой команды»?

Отдельно проверить предположение, что нужен только тест, что отрицательное значение бросает любое исключение. Проверить крайний ввод, при котором полезнее проверить `toString` всех вариантов, не вызывая apply. Считать опасной границей ситуацию, где следует мокировать каждый data object, не создавая реальных команд. Snapshot-тест строк может пройти после неверной перестановки бизнес-действий, если представление не отражает эффект. Проверить соседний случай: Один тест Start достаточен, потому что when уже проверяет все ветви.

Вопрос 7 из 25

Какой побочный эффект существеннее остальных после правки «Эволюция sealed-состояния»: Не добавлять общий `else` в доменном `when`, если новый вариант обязан заставить каждого потребителя принять решение?

Закрытая модель безопасна для конечного набора состояний, но хуже подходит к расширяемой экосистеме сторонних реализаций. Новый риск связан с тем, что новый вариант автоматически попадёт в ветвь Loading. Обратная сторона изменения состоит в том, что ошибка появится только при первом объекте Empty во время выполнения. После правки останется ограничение: Sealed-иерархию нельзя расширять после первого объявления даже в исходном модуле. Решение оправдано лишь при условии: Функция продолжит компилироваться и вернёт пустую строку.

Вопрос 8 из 25

Что важно в ветвях `when` кроме исчерпывающего перечисления?

// Проследите фактическое выполнение без изменения кода.
sealed interface Result
class Ok(val value: Int) : Result
class Error(val cause: Throwable) : Result

fun valueOrZero(r: Result) = when (r) {
    is Ok -> r.value
    is Error -> 0
}

Smart cast возникает только после ручного `as Ok`. В каждой ветви действует smart cast к конкретному подтипу, поэтому доступно `r.value` без явного cast. Обе ветви получают статический тип Any, потому что Result — интерфейс. When создаёт новый объект подтипа перед выполнением ветви. Ветка Error выполняется первой для любого исключения в Ok.

Вопрос 9 из 25

Почему поведение «Состояние как сумма вариантов» не является случайностью?

// На ревью требуется объяснить причину поведения.
sealed interface Checkout
data object Idle : Checkout
data class Editing(val total: Int) : Checkout
data class Paying(val requestId: String) : Checkout
data class Done(val receipt: String) : Checkout

fun canEdit(s: Checkout) = s is Idle || s is Editing

Наблюдаемое поведение выводят из того, что sealed автоматически синхронизирует изменение состояния между потоками. Здесь действует следующее правило: Data class запрещает создать два состояния одновременно в разных объектах. Ключевым считают контракт: Компилятор проверяет допустимость всех переходов между подтипами без дополнительного кода. Алгебраическая модель «один из вариантов» делает невозможные комбинации непредставимыми, но переходы всё равно задаются логикой приложения. Такой результат объясняют тем, что иерархия сохраняет историю предыдущих состояний внутри каждого объекта.

Вопрос 10 из 25

Какая правка устраняет причину риска в «Добавление нового варианта», а не только его проявление?

// Сохраните назначение фрагмента, но укрепите его контракт.
sealed interface Payment
data class Card(val last4: String) : Payment
data object Cash : Payment

fun audit(p: Payment) = when (p) {
    is Card -> "card:${p.last4}"
    Cash -> "cash"
}

Спрятать участок за вспомогательной функцией, сохранив предположение: Добавить общий else во все when, чтобы новая ветвь не требовала изменений. Оставить реализацию без изменений и закрепить тестом предположение: Сделать BankTransfer наследником Card, чтобы старые ветви считали его картой. Вынести участок в отдельный метод, считая верным следующее: Заменить sealed interface на Any и проверять строки имён классов. Перенести проверку в вызывающий код, исходя из того, что сначала выпустить новый JSON, а код потребителей оставить до первого реального перевода. Совместить компиляционный проход с проверкой форматов хранения, сетевых схем и поведения старых клиентов.

Вопрос 11 из 25

Что даст добавление нового прямого варианта `Empty` без изменения `label`?

// Проследите фактическое выполнение без изменения кода.
sealed interface LoadState
data object Loading : LoadState
data class Ready(val items: Int) : LoadState
data class Failed(val message: String) : LoadState

fun label(s: LoadState) = when (s) {
    Loading -> "..."
    is Ready -> "${s.items}"
    is Failed -> s.message
}

Новый вариант автоматически попадёт в ветвь Loading. Компилятор отметит `when` как неисчерпывающий, поэтому забытый случай обнаружится при сборке. Функция продолжит компилироваться и вернёт пустую строку. Ошибка появится только при первом объекте Empty во время выполнения. Sealed-иерархию нельзя расширять после первого объявления даже в исходном модуле.

Вопрос 12 из 25

Какой контракт определяет наблюдаемый результат «Smart cast в ветви when»?

// На ревью требуется объяснить причину поведения.
sealed interface Result
class Ok(val value: Int) : Result
class Error(val cause: Throwable) : Result

fun valueOrZero(r: Result) = when (r) {
    is Ok -> r.value
    is Error -> 0
}

Наблюдаемое поведение выводят из того, что ветка Error выполняется первой для любого исключения в Ok. Причину поведения формулируют так: Smart cast возникает только после ручного `as Ok`. `when` сочетает проверку типа, условие и выражение результата; порядок важен, если ветви пересекаются. Ключевым считают контракт: When создаёт новый объект подтипа перед выполнением ветви. Объяснение опирается на утверждение: Обе ветви получают статический тип Any, потому что Result — интерфейс.

Вопрос 13 из 25

Какую точечную правку стоит принять на ревью фрагмента «Состояние как сумма вариантов»?

// Сохраните назначение фрагмента, но укрепите его контракт.
sealed interface Checkout
data object Idle : Checkout
data class Editing(val total: Int) : Checkout
data class Paying(val requestId: String) : Checkout
data class Done(val receipt: String) : Checkout

fun canEdit(s: Checkout) = s is Idle || s is Editing

Оставить структуру прежней, документировав утверждение: Компилятор проверяет допустимость всех переходов между подтипами без дополнительного кода. Обернуть операцию проверкой и не менять основной контракт: Иерархия сохраняет историю предыдущих состояний внутри каждого объекта. Хранить минимальные данные в каждом варианте и проверять допустимые переходы в одном reducer или доменном объекте. Оставить реализацию без изменений и закрепить тестом предположение: Sealed автоматически синхронизирует изменение состояния между потоками. Вынести участок в отдельный метод, считая верным следующее: Data class запрещает создать два состояния одновременно в разных объектах.

Вопрос 14 из 25

Какой контрпример точнее всего показывает границу «Добавление нового варианта»?

Добавить граничный тест на утверждение: Добавить общий else во все when, чтобы новая ветвь не требовала изменений. Отдельно воспроизвести случай, в котором сначала выпустить новый JSON, а код потребителей оставить до первого реального перевода. Воспроизвести редкий сценарий, где сделать BankTransfer наследником Card, чтобы старые ветви считали его картой. Старый сериализованный вариант может оказаться неизвестен новой версии или наоборот; это не решается исчерпывающим `when` само по себе. Проверить границу полезности утверждения: Заменить sealed interface на Any и проверять строки имён классов.

Вопрос 15 из 25

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

Табличные тесты сокращают повторение, но не должны скрывать отдельный сценарий, требующий особой подготовки или проверки. Обратная сторона изменения состоит в том, что один тест Start достаточен, потому что when уже проверяет все ветви. Главная цена решения — необходимость учитывать, что следует мокировать каждый data object, не создавая реальных команд. Граница полезности решения описывается условием: Полезнее проверить `toString` всех вариантов, не вызывая apply. После правки останется ограничение: Нужен только тест, что отрицательное значение бросает любое исключение.

Вопрос 16 из 25

Что следует изменить прежде всего во фрагменте «Smart cast в ветви when»?

// Сохраните назначение фрагмента, но укрепите его контракт.
sealed interface Result
class Ok(val value: Int) : Result
class Error(val cause: Throwable) : Result

fun valueOrZero(r: Result) = when (r) {
    is Ok -> r.value
    is Error -> 0
}

Добавить локальную обработку результата, потому что when создаёт новый объект подтипа перед выполнением ветви. Зафиксировать текущее поведение регрессионным тестом: Ветка Error выполняется первой для любого исключения в Ok. Ставить более специфичные проверки до широких и выбирать названия ветвей, отражающие предметный смысл, а не только класс. Оставить структуру прежней, документировав утверждение: Smart cast возникает только после ручного `as Ok`. Обернуть операцию проверкой и не менять основной контракт: Обе ветви получают статический тип Any, потому что Result — интерфейс.

Вопрос 17 из 25

Какой сценарий выявит скрытое ограничение «Состояние как сумма вариантов»?

Добавить тест на состояние, при котором компилятор проверяет допустимость всех переходов между подтипами без дополнительного кода. Если в состояние положить изменяемый объект, снимок перестаёт быть устойчивым и сравнение предыдущего/нового состояния становится ненадёжным. Проверить границу полезности утверждения: Data class запрещает создать два состояния одновременно в разных объектах. Отдельно проверить предположение, что иерархия сохраняет историю предыдущих состояний внутри каждого объекта. Воспроизвести редкий сценарий, где sealed автоматически синхронизирует изменение состояния между потоками.

Вопрос 18 из 25

Команда собирается совместить компиляционный проход с проверкой форматов хранения, сетевых схем и поведения старых клиентов. Что придётся учитывать после внедрения в «Добавление нового варианта»?

Граница полезности решения описывается условием: Сделать BankTransfer наследником Card, чтобы старые ветви считали его картой. После правки останется ограничение: Добавить общий else во все when, чтобы новая ветвь не требовала изменений. Главная цена решения — необходимость учитывать, что сначала выпустить новый JSON, а код потребителей оставить до первого реального перевода. Строгая модель делает изменения заметными, зато каждое новое состояние требует осознанной миграции всех границ системы. Главный риск формулируют так: Заменить sealed interface на Any и проверять строки имён классов.

Вопрос 19 из 25

Какой набор тестов даёт наибольшую пользу?

// Проследите фактическое выполнение без изменения кода.
sealed interface Command
data object Start : Command
data object Stop : Command
data class SetRate(val value: Int) : Command

fun apply(c: Command): String = when (c) {
    Start -> "started"
    Stop -> "stopped"
    is SetRate -> require(c.value > 0).let { "rate=${c.value}" }
}

Один тест Start достаточен, потому что when уже проверяет все ветви. Полезнее проверить `toString` всех вариантов, не вызывая apply. Проверить каждый вариант и границы `SetRate` 0 и 1. Нужен только тест, что отрицательное значение бросает любое исключение. Следует мокировать каждый data object, не создавая реальных команд.

Вопрос 20 из 25

Почему пример «Эволюция sealed-состояния» даёт именно такой результат?

// На ревью требуется объяснить причину поведения.
sealed interface LoadState
data object Loading : LoadState
data class Ready(val items: Int) : LoadState
data class Failed(val message: String) : LoadState

fun label(s: LoadState) = when (s) {
    Loading -> "..."
    is Ready -> "${s.items}"
    is Failed -> s.message
}

Причину поведения формулируют так: Ошибка появится только при первом объекте Empty во время выполнения. Семантика фрагмента приводит к тому, что новый вариант автоматически попадёт в ветвь Loading. Контракт здесь понимают так: Функция продолжит компилироваться и вернёт пустую строку. Sealed-класс или интерфейс ограничивает известную иерархию модулем и пакетом, позволяя компилятору анализировать исчерпывающие `when`. Объяснение опирается на утверждение: Sealed-иерархию нельзя расширять после первого объявления даже в исходном модуле.

Вопрос 21 из 25

Команда собирается хранить минимальные данные в каждом варианте и проверять допустимые переходы в одном reducer или доменном объекте. Что придётся учитывать после внедрения в «Состояние как сумма вариантов»?

Главная цена решения — необходимость учитывать, что data class запрещает создать два состояния одновременно в разных объектах. После правки останется ограничение: Sealed автоматически синхронизирует изменение состояния между потоками. Главный риск формулируют так: Компилятор проверяет допустимость всех переходов между подтипами без дополнительного кода. Явные варианты упрощают интерфейс и тесты, но слишком дробная иерархия может раздуть число переходов и шаблонного кода. После внедрения придётся исходить из того, что иерархия сохраняет историю предыдущих состояний внутри каждого объекта.

Вопрос 22 из 25

Команда добавляет `BankTransfer`. Какой порядок изменений надёжнее?

// Проследите фактическое выполнение без изменения кода.
sealed interface Payment
data class Card(val last4: String) : Payment
data object Cash : Payment

fun audit(p: Payment) = when (p) {
    is Card -> "card:${p.last4}"
    Cash -> "cash"
}

Сделать BankTransfer наследником Card, чтобы старые ветви считали его картой. Сначала выпустить новый JSON, а код потребителей оставить до первого реального перевода. Заменить sealed interface на Any и проверять строки имён классов. Добавить общий else во все when, чтобы новая ветвь не требовала изменений. Сначала добавить вариант и исправить все ошибки исчерпывающих `when`, затем обновить сериализацию, миграции и контрактные тесты.

Вопрос 23 из 25

Что в семантике Kotlin или используемого API объясняет «Тестирование закрытой команды»?

// На ревью требуется объяснить причину поведения.
sealed interface Command
data object Start : Command
data object Stop : Command
data class SetRate(val value: Int) : Command

fun apply(c: Command): String = when (c) {
    Start -> "started"
    Stop -> "stopped"
    is SetRate -> require(c.value > 0).let { "rate=${c.value}" }
}

Семантика фрагмента приводит к тому, что следует мокировать каждый data object, не создавая реальных команд. Поведение связывают с правилом: Полезнее проверить `toString` всех вариантов, не вызывая apply. Механика примера описывается утверждением: Один тест Start достаточен, потому что when уже проверяет все ветви. Причина результата в том, что нужен только тест, что отрицательное значение бросает любое исключение. Компилятор проверяет покрытие типов, но не правильность результата, инварианты данных или побочные эффекты ветви.

Вопрос 24 из 25

Что изменить в «Эволюция sealed-состояния», чтобы скрытое допущение стало явным контрактом?

// Сохраните назначение фрагмента, но укрепите его контракт.
sealed interface LoadState
data object Loading : LoadState
data class Ready(val items: Int) : LoadState
data class Failed(val message: String) : LoadState

fun label(s: LoadState) = when (s) {
    Loading -> "..."
    is Ready -> "${s.items}"
    is Failed -> s.message
}

Оставить структуру прежней, документировав утверждение: Ошибка появится только при первом объекте Empty во время выполнения. Обернуть операцию проверкой и не менять основной контракт: Sealed-иерархию нельзя расширять после первого объявления даже в исходном модуле. Оставить реализацию без изменений и закрепить тестом предположение: Новый вариант автоматически попадёт в ветвь Loading. Не добавлять общий `else` в доменном `when`, если новый вариант обязан заставить каждого потребителя принять решение. Вынести участок в отдельный метод, считая верным следующее: Функция продолжит компилироваться и вернёт пустую строку.

Вопрос 25 из 25

Какой дополнительный сценарий нужен для «Smart cast в ветви when»?

Проверить, сохраняется ли контракт, когда ветка Error выполняется первой для любого исключения в Ok. Зафиксировать сценарий, где ожидается: Обе ветви получают статический тип Any, потому что Result — интерфейс. Добавить граничный тест на утверждение: When создаёт новый объект подтипа перед выполнением ветви. Условия с произвольными выражениями могут иметь побочные эффекты; их порядок становится частью поведения и затрудняет тесты. Считать опасной границей ситуацию, где smart cast возникает только после ручного `as Ok`.